ggaction 0.0.2 → 0.0.4

package/src/actions/marks/rect/actions.js

@@ -0,0 +1,165 @@
+import { action } from "../../../core/action.js";
+import { validateUserId } from "../../../core/identifiers.js";
+import {
+  DEFAULT_RECT_MARK,
+  normalizeRectMarkConfig
+} from "../../../materialization/rectConfig.js";
+import {
+  canMaterializeRect
+} from "../../../materialization/marks/index.js";
+import { resolveRectGraphicItems } from "../../../materialization/rect.js";
+import { findDataset } from "../../../selectors/datasets.js";
+import { findLayer, resolveEligibleLayer } from "../../../selectors/layers.js";
+import {
+  assertMarkAvailable,
+  applyLayeredMarkInheritance,
+  materializeInheritedMark,
+  resolveLayeredMarkInheritance,
+  resolveMarkData,
+  resolveMarkId,
+  validateMarkOptions
+} from "../shared.js";
+import { resolveMarkGraphicPlacement } from
+  "../../../materialization/graphicHierarchy.js";
+import { rematerializeHighlightBaseline } from "../lifecycle.js";
+
+const STYLE_OPTIONS = Object.freeze([
+  "fill", "opacity", "stroke", "strokeWidth"
+]);
+const CREATE_OPTIONS = Object.freeze(["id", "data", ...STYLE_OPTIONS]);
+const EDIT_OPTIONS = Object.freeze(["target", ...STYLE_OPTIONS]);
+const REMATERIALIZE_OPTIONS = Object.freeze(["id", "scales"]);
+
+function requireRectLayer(program, requested, operation) {
+  const target = requested === undefined
+    ? undefined
+    : validateUserId(requested, "Rect mark id");
+  return resolveEligibleLayer(program, {
+    target,
+    predicate: layer => layer.mark?.type === "rect",
+    label: `${operation} rect mark`
+  });
+}
+
+const createRectMark = action(
+  { op: "createRectMark", description: "Create a semantic rectangular cell layer." },
+  function (args = {}) {
+    validateMarkOptions(args, CREATE_OPTIONS, "createRectMark");
+    const id = resolveMarkId(this, args.id, {
+      defaultId: "rect",
+      label: "Rect mark id",
+      markType: "rect",
+      operation: "createRectMark"
+    });
+    const inherited = resolveLayeredMarkInheritance(this, args, "rect");
+    const { data } = resolveMarkData(this, {
+      ...args,
+      ...(args.data === undefined && this.context.currentData === undefined &&
+        inherited?.data !== undefined ? { data: inherited.data } : {})
+    });
+    assertMarkAvailable(this, id);
+
+    let next = this
+      .editSemantic({ property: `layer[${id}].mark.type`, value: "rect" })
+      .editSemantic({ property: `layer[${id}].data`, value: data });
+    next = applyLayeredMarkInheritance(next, id, inherited)
+      .createGraphics({
+        id,
+        type: "rect",
+        length: 0,
+        ...resolveMarkGraphicPlacement(next, { data, markType: "rect" })
+      })
+      ._withMarkConfig(id, { ...DEFAULT_RECT_MARK, fillExplicit: false });
+    next = materializeInheritedMark(next, id);
+    const style = Object.fromEntries(
+      STYLE_OPTIONS.filter(option => Object.hasOwn(args, option))
+        .map(option => [option, args[option]])
+    );
+    return Object.keys(style).length === 0
+      ? next
+      : next.editRectMark({ target: id, ...style });
+  }
+);
+
+const rematerializeRectMark = action(
+  { op: "rematerializeRectMark", description: "Recompute concrete rectangular cells." },
+  function (args = {}) {
+    validateMarkOptions(args, REMATERIALIZE_OPTIONS, "rematerializeRectMark");
+    const id = validateUserId(args.id, "Rect mark id");
+    if (args.scales !== undefined && typeof args.scales !== "boolean") {
+      throw new TypeError("rematerializeRectMark scales must be a boolean.");
+    }
+    const highlighted = rematerializeHighlightBaseline(this, {
+      target: id,
+      operation: "rematerializeRectMark",
+      resetProperty: "items",
+      resetValue: []
+    });
+    if (highlighted !== undefined) return highlighted;
+    const layer = findLayer(this, id);
+    const graphic = this.graphicSpec.objects[id];
+    if (layer?.mark?.type !== "rect") throw new Error(`Unknown rect mark "${id}".`);
+    if (graphic?.type !== "rect" || !Array.isArray(graphic.items)) {
+      throw new Error(`Rect mark "${id}" requires rect collection graphics.`);
+    }
+    const dataset = findDataset(this, layer.data);
+    if (dataset === undefined) {
+      throw new Error(`Rect mark "${id}" requires an existing dataset.`);
+    }
+    if (!canMaterializeRect(this, layer)) {
+      return graphic.items.length === 0
+        ? this
+        : this.editGraphics({ target: id, property: "items", value: [] });
+    }
+    let next = this;
+    if (args.scales !== false) {
+      const ids = new Set(["x", "y", "x2", "y2", "color"].flatMap(channel => {
+        const scale = layer.encoding?.[channel]?.scale;
+        return scale === undefined ? [] : [scale];
+      }));
+      for (const scale of ids) {
+        next = next.rematerializeScale({ id: scale, marks: false });
+      }
+    }
+    return next.editGraphics({
+      target: id,
+      property: "items",
+      value: resolveRectGraphicItems(next, layer, dataset)
+    });
+  }
+);
+
+const editRectMark = action(
+  { op: "editRectMark", description: "Edit rectangular cell appearance." },
+  function (args = {}) {
+    validateMarkOptions(args, EDIT_OPTIONS, "editRectMark");
+    if (!STYLE_OPTIONS.some(option => Object.hasOwn(args, option))) {
+      throw new Error("editRectMark requires at least one editable property.");
+    }
+    const layer = requireRectLayer(this, args.target, "editRectMark");
+    if (Object.hasOwn(args, "fill") && layer.encoding?.color !== undefined) {
+      throw new Error("editRectMark fill cannot be combined with a color encoding.");
+    }
+    const next = this._withMarkConfig(
+      layer.id,
+      {
+        ...normalizeRectMarkConfig(
+          args,
+          this.markConfigs[layer.id] ?? DEFAULT_RECT_MARK
+        ),
+        fillExplicit: Object.hasOwn(args, "fill")
+          ? true
+          : this.markConfigs[layer.id]?.fillExplicit ?? false
+      }
+    );
+    return canMaterializeRect(next, layer)
+      ? next.rematerializeRectMark({ id: layer.id })
+      : next;
+  }
+);
+
+export function registerRectMarkActions(ProgramClass) {
+  ProgramClass.prototype.createRectMark = createRectMark;
+  ProgramClass.prototype.editRectMark = editRectMark;
+  ProgramClass.prototype.rematerializeRectMark = rematerializeRectMark;
+}

package/src/actions/marks/rect/index.js

@@ -0,0 +1 @@
+export { registerRectMarkActions } from "./actions.js";

package/src/actions/marks/remove.js

@@ -0,0 +1,214 @@
+import { action } from "../../core/action.js";
+import { validateUserId } from "../../core/identifiers.js";
+import { validateKeys } from "../../core/validation.js";
+import { findDataset } from "../../selectors/datasets.js";
+import { findLayer } from "../../selectors/layers.js";
+import {
+  getPositionChannelDefinition,
+  POSITION_CHANNELS
+} from "../../core/vocabulary.js";
+
+const OPTIONS = Object.freeze(["target"]);
+const REMOVE_AXIS = Object.freeze({
+  x: "removeXAxis",
+  y: "removeYAxis",
+  theta: "removeThetaAxis",
+  radius: "removeRadialAxis"
+});
+
+function ownedChildren(program, id) {
+  const config = program.markConfigs[id] ?? {};
+  return [
+    config.errorBar?.lowerCapId,
+    config.errorBar?.upperCapId,
+    config.errorBand?.lowerBoundaryId,
+    config.errorBand?.upperBoundaryId,
+    config.regression?.bandId,
+    config.regression?.lineId,
+    config.boxPlot?.whiskerId,
+    config.boxPlot?.medianId,
+    config.boxPlot?.outlierId
+  ].concat(
+    program.semanticSpec.layers
+      .filter(layer => layer.source === id)
+      .map(layer => layer.id)
+  ).filter(child => child !== undefined && findLayer(program, child) !== undefined);
+}
+
+function ownership(program) {
+  const ownerByChild = new Map();
+  for (const layer of program.semanticSpec.layers) {
+    for (const child of ownedChildren(program, layer.id)) {
+      ownerByChild.set(child, layer.id);
+    }
+  }
+  return ownerByChild;
+}
+
+function resolveOwner(program, requested) {
+  const ownerByChild = ownership(program);
+  const stable = program.semanticSpec.layers.filter(
+    layer => !ownerByChild.has(layer.id)
+  );
+  if (requested !== undefined) {
+    const id = validateUserId(requested, "Mark owner id");
+    const layer = findLayer(program, id);
+    if (layer === undefined) throw new Error(`Unknown mark target "${id}".`);
+    if (ownerByChild.has(id)) {
+      throw new Error(
+        `Mark "${id}" is owned by "${ownerByChild.get(id)}"; remove its stable owner.`
+      );
+    }
+    return layer;
+  }
+  const current = findLayer(program, program.context.currentMark);
+  if (current !== undefined && stable.includes(current)) return current;
+  if (stable.length === 1) return stable[0];
+  if (stable.length === 0) throw new Error("removeMark requires an existing mark.");
+  throw new Error("removeMark target is ambiguous; provide target.");
+}
+
+function collectClosure(program, root) {
+  const result = [];
+  const visit = id => {
+    for (const child of ownedChildren(program, id)) visit(child);
+    if (!result.includes(id)) result.push(id);
+  };
+  visit(root);
+  return result;
+}
+
+function ownedDerivedData(program, ids) {
+  const candidates = new Set();
+  for (const id of ids) {
+    const layer = findLayer(program, id);
+    const config = program.markConfigs[id] ?? {};
+    for (const candidate of [
+      config.errorBar?.data,
+      config.errorBand?.data,
+      config.regression?.dataId,
+      config.boxPlot?.summaryId,
+      config.boxPlot?.outlierDataId
+    ]) {
+      if (candidate !== undefined) candidates.add(candidate);
+    }
+    const dataset = findDataset(program, layer?.data);
+    if (dataset?.transform?.[0]?.type === "markFilter") {
+      candidates.add(dataset.id);
+    }
+  }
+  return candidates;
+}
+
+function usedPositionScales(program, ids) {
+  const scales = Object.fromEntries(
+    POSITION_CHANNELS.map(channel => [channel, new Set()])
+  );
+  for (const id of ids) {
+    const layer = findLayer(program, id);
+    for (const channel of POSITION_CHANNELS) {
+      const scale = layer?.encoding?.[channel]?.scale;
+      if (scale !== undefined) scales[channel].add(scale);
+    }
+  }
+  return scales;
+}
+
+function cleanupSelectionState(program, ids) {
+  const targets = new Set(ids);
+  const selectionIds = Object.entries(program.materializationConfigs.selections ?? {})
+    .filter(([, config]) => targets.has(config.target))
+    .map(([id]) => id);
+  let next = program;
+  for (const [id, config] of Object.entries(
+    program.materializationConfigs.highlights ?? {}
+  )) {
+    if (targets.has(config.target) || selectionIds.includes(config.selection)) {
+      next = next._withoutMaterializationConfig(["highlights", id]);
+    }
+  }
+  for (const id of selectionIds) {
+    next = next._withoutMaterializationConfig(["selections", id]);
+  }
+  return {
+    program: next,
+    selectionIds
+  };
+}
+
+function hasScaleConsumer(program, channel, scale) {
+  return program.semanticSpec.layers.some(
+    layer => layer.encoding?.[channel]?.scale === scale
+  );
+}
+
+function cleanupPositionGuides(program, scales) {
+  let next = program;
+  for (const channel of POSITION_CHANNELS) {
+    const definition = getPositionChannelDefinition(channel);
+    const axis = next.semanticSpec.guides.axis?.[channel];
+    if (
+      axis !== undefined &&
+      scales[channel].has(axis.scale) &&
+      !hasScaleConsumer(next, channel, axis.scale)
+    ) {
+      next = next[REMOVE_AXIS[channel]]({
+        scale: axis.scale,
+        ...(axis.coordinate === undefined ? {} : { coordinate: axis.coordinate })
+      });
+    }
+    const grid = next.semanticSpec.guides.grid?.[definition.gridDirection];
+    if (
+      grid !== undefined &&
+      scales[channel].has(grid.scale) &&
+      !hasScaleConsumer(next, channel, grid.scale)
+    ) {
+      next = next.removeGrid({ [definition.gridDirection]: true });
+    }
+  }
+  return next;
+}
+
+export const removeMark = action(
+  { op: "removeMark", description: "Remove one stable mark owner and owned state." },
+  function (args = {}) {
+    validateKeys(args, OPTIONS, "removeMark");
+    const owner = resolveOwner(this, args.target);
+    const ids = collectClosure(this, owner.id);
+    const derived = ownedDerivedData(this, ids);
+    const positionScales = usedPositionScales(this, ids);
+    let next = this;
+
+    const legendTargets = [...new Set(Object.values(next.guideConfigs.legend ?? {})
+      .filter(config => ids.includes(config?.target))
+      .map(config => config.target))];
+    for (const target of legendTargets) {
+      next = next.removeLegend({ target });
+    }
+
+    const selectionCleanup = cleanupSelectionState(next, ids);
+    next = selectionCleanup.program;
+    for (const id of ids) {
+      if (findLayer(next, id) !== undefined) {
+        next = next.editSemantic({ property: `layer[${id}]`, remove: true });
+      }
+      if (next.graphicSpec.objects[id] !== undefined) {
+        next = next.editGraphics({ target: id, remove: true });
+      }
+      next = next._withoutMaterializationConfig(["marks", id]);
+    }
+
+    next = cleanupPositionGuides(next, positionScales);
+    for (const id of derived) {
+      if (findDataset(next, id)?.source !== undefined) {
+        next = next.releaseDerivedData({ id });
+      }
+    }
+    return next._withContext({
+      ...(ids.includes(this.context.currentMark) ? { currentMark: undefined } : {}),
+      ...(selectionCleanup.selectionIds.includes(this.context.currentSelection)
+        ? { currentSelection: undefined }
+        : {})
+    });
+  }
+);

package/src/actions/marks/{rule.js → rule/actions.js}

@@ -1,25 +1,29 @@
-import { action } from "../../core/action.js";
-import { validateUserId } from "../../core/identifiers.js";
-import { validatePositiveFinite } from "../../core/validation.js";
+import { action } from "../../../core/action.js";
+import { validateUserId } from "../../../core/identifiers.js";
+import { validatePositiveFinite } from "../../../core/validation.js";
 import {
   mapContinuousScaleValues,
   mapOrdinalPositionValues,
   mapOrdinalValues,
   normalizeStrokeDashPattern
-} from "../../grammar/scales.js";
-import { deriveRuleValues, resolveRuleMode } from "../../grammar/rules.js";
-import { resolveGraphicBounds } from "../../layout/canvas.js";
-import { findDataset } from "../../selectors/datasets.js";
-import { findLayer } from "../../selectors/layers.js";
-import { DEFAULT_COLORS } from "../../theme/defaults.js";
+} from "../../../grammar/scales/index.js";
+import { deriveRuleValues, resolveRuleMode } from "../../../grammar/rules.js";
+import { resolveGraphicBounds } from "../../../layout/canvas.js";
+import { findDataset } from "../../../selectors/datasets.js";
+import { findLayer } from "../../../selectors/layers.js";
+import { DEFAULT_COLORS } from "../../../theme/defaults.js";
 import {
   assertMarkAvailable,
+  applyLayeredMarkInheritance,
+  materializeInheritedMark,
+  resolveLayeredMarkInheritance,
   resolveMarkData,
   resolveMarkId,
   validateMarkOptions
-} from "./shared.js";
+} from "../shared.js";
 import { resolveMarkGraphicPlacement } from
-  "../../materialization/graphicHierarchy.js";
+  "../../../materialization/graphicHierarchy.js";
+import { rematerializeHighlightBaseline } from "../lifecycle.js";
 
 const CREATE_OPTIONS = Object.freeze(["id", "data"]);
 const REMATERIALIZE_OPTIONS = Object.freeze(["id"]);
@@ -81,19 +85,27 @@ const createRuleMark = action(
       markType: "rule",
       operation: "createRuleMark"
     });
-    const { data } = resolveMarkData(this, args);
+    const inherited = resolveLayeredMarkInheritance(this, args, "rule");
+    const { data } = resolveMarkData(this, {
+      ...args,
+      ...(args.data === undefined && this.context.currentData === undefined &&
+        inherited?.data !== undefined ? { data: inherited.data } : {})
+    });
     assertMarkAvailable(this, id);
 
-    return this
+    let created = this
       .editSemantic({ property: `layer[${id}].mark.type`, value: "rule" })
-      .editSemantic({ property: `layer[${id}].data`, value: data })
+      .editSemantic({ property: `layer[${id}].data`, value: data });
+    created = applyLayeredMarkInheritance(created, id, inherited);
+    created = created
       .createGraphics({
         id,
         type: "line",
         length: 0,
-        ...resolveMarkGraphicPlacement(this, { data, markType: "rule" })
+        ...resolveMarkGraphicPlacement(created, { data, markType: "rule" })
       })
       ._withMarkConfig(id, DEFAULT_RULE_CONFIG);
+    return materializeInheritedMark(created, id);
   }
 );
 
@@ -105,19 +117,13 @@ const rematerializeRuleMark = action(
   function (args = {}) {
     validateMarkOptions(args, REMATERIALIZE_OPTIONS, "rematerializeRuleMark");
     const id = validateUserId(args.id, "Rule mark id");
-    const highlights = Object.entries(
-      this.materializationConfigs.highlights ?? {}
-    ).filter(([, config]) => config.target === id);
-    if (highlights.length > 0) {
-      let baseline = this;
-      for (const [highlightId] of highlights) {
-        baseline = baseline._withoutMaterializationConfig(["highlights", highlightId]);
-      }
-      return baseline
-        .editGraphics({ target: id, property: "length", value: 0 })
-        .rematerializeRuleMark({ id })
-        .rematerializeMarkHighlights({ target: id, highlights });
-    }
+    const highlighted = rematerializeHighlightBaseline(this, {
+      target: id,
+      operation: "rematerializeRuleMark",
+      resetProperty: "length",
+      resetValue: 0
+    });
+    if (highlighted !== undefined) return highlighted;
     const { dataset, graphic, layer } = requireRule(this, id);
     validateEndpointBindings(layer);
     const config = this.markConfigs[id] ?? DEFAULT_RULE_CONFIG;

package/src/actions/marks/rule/index.js

@@ -0,0 +1 @@
+export { registerRuleMarkActions } from "./actions.js";