ggaction 0.0.10 → 0.0.12

package/src/actions/marks/text/layout.js

@@ -14,6 +14,7 @@ import { resolveGraphicBounds } from "../../../layout/canvas.js";
 import { canMaterializeText } from "../../../materialization/marks/index.js";
 import { resolveTextGraphicEntries } from "../../../materialization/text.js";
 import { findLayer, resolveEligibleLayer } from "../../../selectors/layers.js";
+import { editMarkGraphic } from "../shared.js";
 
 const LAYOUT_OPTIONS = Object.freeze([
   "target", "axis", "padding", "maxDisplacement", "bounds", "leader"
@@ -170,42 +171,22 @@ function materializeLeaders(program, layer, config, resolved) {
   if (config.leader === false) return { program: next, count: 0 };
   const leaders = resolved.items.map(resolveLabelLeader).filter(Boolean);
   if (leaders.length === 0) return { program: next, count: 0 };
-  next = next
-    .createGraphics({
+  next = next.createGraphics({
       id: config.leaderId,
       type: "line",
       length: leaders.length,
       ...leaderPlacement(next, layer)
-    })
-    .editGraphics({
-      target: config.leaderId,
-      property: "x1",
-      value: leaders.map(line => line.x1)
-    })
-    .editGraphics({
-      target: config.leaderId,
-      property: "y1",
-      value: leaders.map(line => line.y1)
-    })
-    .editGraphics({
-      target: config.leaderId,
-      property: "x2",
-      value: leaders.map(line => line.x2)
-    })
-    .editGraphics({
-      target: config.leaderId,
-      property: "y2",
-      value: leaders.map(line => line.y2)
     });
-  for (const property of ["stroke", "strokeWidth", "strokeDash", "opacity"]) {
-    next = next.editGraphics({
-      target: config.leaderId,
-      property,
-      value: property === "strokeDash"
-        ? leaders.map(() => config.leader.strokeDash)
-        : config.leader[property]
-    });
-  }
+  next = editMarkGraphic(next, config.leaderId, {
+    x1: leaders.map(line => line.x1),
+    y1: leaders.map(line => line.y1),
+    x2: leaders.map(line => line.x2),
+    y2: leaders.map(line => line.y2),
+    stroke: config.leader.stroke,
+    strokeWidth: config.leader.strokeWidth,
+    strokeDash: leaders.map(() => config.leader.strokeDash),
+    opacity: config.leader.opacity
+  });
   return { program: next, count: leaders.length };
 }
 
@@ -237,17 +218,10 @@ const materializeLabelLayout = action(
       padding: config.padding,
       maxDisplacement: config.maxDisplacement
     });
-    next = next
-      .editGraphics({
-        target: id,
-        property: "x",
-        value: resolved.items.map(item => item.x)
-      })
-      .editGraphics({
-        target: id,
-        property: "y",
-        value: resolved.items.map(item => item.y)
-      });
+    next = editMarkGraphic(next, id, {
+      x: resolved.items.map(item => item.x),
+      y: resolved.items.map(item => item.y)
+    });
     const leaders = materializeLeaders(next, layer, config, resolved);
     next = leaders.program;
     return next._withMaterializationConfig(["labelLayouts", id], {
@@ -315,7 +289,9 @@ const removeLabelLayout = action(
 );
 
 export function registerTextLabelLayoutActions(ProgramClass) {
-  ProgramClass.prototype.layoutLabels = layoutLabels;
-  ProgramClass.prototype.removeLabelLayout = removeLabelLayout;
-  ProgramClass.prototype.materializeLabelLayout = materializeLabelLayout;
+  Object.assign(ProgramClass.prototype, {
+    layoutLabels,
+    removeLabelLayout,
+    materializeLabelLayout
+  });
 }

package/src/actions/marks/tick/actions.js

@@ -21,6 +21,7 @@ import { rematerializeHighlightBaseline } from "../lifecycle.js";
 import {
   applyLayeredMarkInheritance,
   assertMarkAvailable,
+  editMarkGraphic,
   materializeInheritedMark,
   resolveLayeredMarkInheritance,
   resolveMarkData,
@@ -28,12 +29,11 @@ import {
   validateMarkOptions
 } from "../shared.js";
 
-const CREATE_OPTIONS = Object.freeze([
-  "id", "data", "length", "stroke", "strokeWidth", "opacity"
-]);
-const EDIT_OPTIONS = Object.freeze([
-  "target", "length", "stroke", "strokeWidth", "opacity"
+const APPEARANCE_OPTIONS = Object.freeze([
+  "length", "stroke", "strokeWidth", "opacity"
 ]);
+const CREATE_OPTIONS = Object.freeze(["id", "data", ...APPEARANCE_OPTIONS]);
+const EDIT_OPTIONS = Object.freeze(["target", ...APPEARANCE_OPTIONS]);
 const REMATERIALIZE_OPTIONS = Object.freeze(["id"]);
 
 export const DEFAULT_TICK_CONFIG = Object.freeze({
@@ -116,8 +116,7 @@ export const createTickMark = action(
       ._withMarkConfig(id, DEFAULT_TICK_CONFIG);
     const materialized = materializeInheritedMark(created, id);
     const appearance = Object.fromEntries(
-      ["length", "stroke", "strokeWidth", "opacity"]
-        .filter(property => Object.hasOwn(args, property))
+      APPEARANCE_OPTIONS.filter(property => Object.hasOwn(args, property))
         .map(property => [property, config[property]])
     );
     return Object.keys(appearance).length === 0
@@ -133,8 +132,7 @@ export const editTickMark = action(
   },
   function (args = {}) {
     validateMarkOptions(args, EDIT_OPTIONS, "editTickMark");
-    const editable = ["length", "stroke", "strokeWidth", "opacity"];
-    if (!editable.some(property => Object.hasOwn(args, property))) {
+    if (!APPEARANCE_OPTIONS.some(property => Object.hasOwn(args, property))) {
       throw new Error(
         "editTickMark requires length, stroke, strokeWidth, or opacity."
       );
@@ -206,20 +204,23 @@ export const rematerializeTickMark = action(
       })
     );
 
-    return this
-      .editGraphics({ target: id, property: "length", value: segments.length })
-      .editGraphics({ target: id, property: "x1", value: segments.map(item => item.x1) })
-      .editGraphics({ target: id, property: "y1", value: segments.map(item => item.y1) })
-      .editGraphics({ target: id, property: "x2", value: segments.map(item => item.x2) })
-      .editGraphics({ target: id, property: "y2", value: segments.map(item => item.y2) })
-      .editGraphics({ target: id, property: "stroke", value: config.stroke })
-      .editGraphics({ target: id, property: "strokeWidth", value: config.strokeWidth })
-      .editGraphics({ target: id, property: "opacity", value: config.opacity });
+    return editMarkGraphic(this, id, {
+      length: segments.length,
+      x1: segments.map(item => item.x1),
+      y1: segments.map(item => item.y1),
+      x2: segments.map(item => item.x2),
+      y2: segments.map(item => item.y2),
+      stroke: config.stroke,
+      strokeWidth: config.strokeWidth,
+      opacity: config.opacity
+    });
   }
 );
 
 export function registerTickMarkActions(ProgramClass) {
-  ProgramClass.prototype.createTickMark = createTickMark;
-  ProgramClass.prototype.editTickMark = editTickMark;
-  ProgramClass.prototype.rematerializeTickMark = rematerializeTickMark;
+  Object.assign(ProgramClass.prototype, {
+    createTickMark,
+    editTickMark,
+    rematerializeTickMark
+  });
 }

package/src/actions/primitives/createGraphics.js

@@ -1,6 +1,7 @@
 import { action } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
 import { freezeOwned } from "../../core/immutable.js";
+import { validateGeneratedItemLimit } from "../../core/validation.js";
 import {
   isDrawableGraphicType,
   isGraphicContainerType,
@@ -115,6 +116,9 @@ const createGraphics = action(
     if (length !== undefined && (!Number.isInteger(length) || length < 0)) {
       throw new TypeError("createGraphics length must be a non-negative integer.");
     }
+    if (length !== undefined) {
+      validateGeneratedItemLimit(length, "createGraphics length");
+    }
     if (validatedType === "collection" && length !== undefined) {
       throw new Error("Heterogeneous collections use editGraphics items instead of length.");
     }

package/src/actions/primitives/editGraphics.js

@@ -1,5 +1,6 @@
 import { action } from "../../core/action.js";
 import { cloneAndFreeze, freezeOwned, isPlainObject } from "../../core/immutable.js";
+import { validateGeneratedItemLimit } from "../../core/validation.js";
 import {
   isPrimitiveDrawableGraphicType,
   isStructuralGraphicType,
@@ -44,6 +45,7 @@ function validateCollectionItem(item, ownerId, index) {
 
 function replaceCollectionItems(value, id) {
   if (!Array.isArray(value)) throw new TypeError("collection.items must be an array.");
+  validateGeneratedItemLimit(value.length, "collection.items length");
   return freezeOwned(value.map((item, index) => validateCollectionItem(item, id, index)));
 }
 
@@ -82,6 +84,7 @@ function editItems(owner, property, value, id) {
     if (!Number.isInteger(value) || value < 0) {
       throw new TypeError("Graphic collection length must be a non-negative integer.");
     }
+    validateGeneratedItemLimit(value, "Graphic collection length");
     const items = owner.items.slice(0, value);
     for (let index = items.length; index < value; index += 1) {
       if (owner.type === "collection") {
@@ -187,6 +190,7 @@ const editGraphics = action(
       if (!Number.isInteger(value) || value < 0) {
         throw new TypeError("Graphic collection length must be a non-negative integer.");
       }
+      validateGeneratedItemLimit(value, "Graphic collection length");
       updated = freezeOwned({
         type: owner.type,
         items: freezeOwned(Array.from({ length: value }, (_, index) => freezeOwned({

package/src/actions/primitives/index.js

@@ -1,10 +1,10 @@
+import { createSemanticValueValidator } from "./semanticValidation/index.js";
 import { isPlainObject } from "../../core/immutable.js";
 import { validateBin2DTransform } from "../../grammar/bin2d.js";
-import { registerCreateGraphicsAction } from "./createGraphics.js";
-import { registerEditGraphicsAction } from "./editGraphics.js";
 import { registerSemanticPrimitiveAction } from "./semantic.js";
+import { registerEditGraphicsAction } from "./editGraphics.js";
+import { registerCreateGraphicsAction } from "./createGraphics.js";
 import { createSemanticPrimitiveAction } from "./semanticAction.js";
-import { createSemanticValueValidator } from "./semanticValidation/index.js";
 
 function validateBasicDatasetTransforms(value) {
   if (!Array.isArray(value) || value.length !== 1 || !isPlainObject(value[0])) {

package/src/actions/primitives/semantic.js

@@ -21,7 +21,7 @@ export function registerSemanticPrimitiveAction(ProgramClass) {
   const validateSemanticValue = createSemanticValueValidator({
     validateDatasetTransforms,
     validateParallel,
-    sourceMarkTypes: ["point", "bar", "rule", "rect"]
+    sourceMarkTypes: ["point", "bar", "rule", "rect", "arc"]
   });
   ProgramClass.prototype.editSemantic =
     createSemanticPrimitiveAction(validateSemanticValue);

package/src/actions/primitives/semanticValidation/index.js

@@ -1,8 +1,8 @@
 import { validateCoordinateType } from "../../../grammar/coordinates.js";
+import { validateScaleSemanticValue } from "./scale.js";
 import { validateDatasetSemanticValue } from "./dataset.js";
-import { validateGuideSemanticValue } from "./guide.js";
 import { validateLayerSemanticValue } from "./layer.js";
-import { validateScaleSemanticValue } from "./scale.js";
+import { validateGuideSemanticValue } from "./guide.js";
 import { validateNonEmptySemanticString } from "./shared.js";
 
 export function createSemanticValueValidator({

package/src/actions/primitives/semanticValidation/layer.js

@@ -40,7 +40,7 @@ export function validateLayerSemanticValue(
   parsed,
   value,
   {
-    sourceMarkTypes = ["point", "bar", "rule", "rect"],
+    sourceMarkTypes = ["point", "bar", "rule", "rect", "arc"],
     validateParallel
   } = {}
 ) {

package/src/actions/regression/edit.js

@@ -12,7 +12,8 @@ import { validateCurveInterpolation } from "../../grammar/curveCommands.js";
 import { planDerivedDataRevision } from
   "../../materialization/dataProvenance.js";
 import { findLayer } from "../../selectors/layers.js";
-import { removeLegendKinds } from "../guides/legends/remove.js";
+import { removeOwnedMark } from "../marks/remove.js";
+import { removeOwnedColorLegends } from "../guides/legends/remove.js";
 import { requireRegressionField } from "./resolve.js";
 
 const OPTIONS = Object.freeze([
@@ -118,46 +119,6 @@ function resolveParameters(previous, args) {
   return normalizeRegressionParameters(raw);
 }
 
-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);
-}
-
-function removeBand(program, id) {
-  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 }
-        : {})
-    });
-}
-
 function regressionColorScale(owner, current, groupBy) {
   if (groupBy === undefined || groupBy === current.groupBy) {
     return current.colorScale;
@@ -331,7 +292,7 @@ export const editRegression = action(
 
       let bandId = current.bandId;
       if (hadBand && !wantsBand) {
-        next = removeBand(next, current.bandId);
+        next = removeOwnedMark(next, current.bandId);
         bandId = undefined;
       } else if (!hadBand && wantsBand) {
         bandId = `${owner.id}RegressionBands`;
@@ -400,7 +361,6 @@ export const editRegression = action(
         }
       });
     };
-    if (changesStatistics || hadBand !== wantsBand) applyEdit(this);
     return applyEdit(this);
   }
 );

package/src/actions/scales/consumers/families.js

@@ -5,14 +5,27 @@ import {
 } from "../../../grammar/bars/policy.js";
 import {
   deriveLineSeries,
-  deriveLineSeriesFieldValues
+  deriveLineSeriesFieldValues,
+  resolveLineBins
 } from "../../../grammar/lineSeries.js";
 import { isAggregate } from "../../../grammar/aggregate.js";
 import {
   resolveRectConsumerValues
 } from "../../../materialization/rect.js";
+import { findScale } from "./common.js";
 
-export function resolveMarkFamilyConsumerValues(consumer, dataset) {
+function lineDerivationOptions(program, consumer, dataset) {
+  const x = consumer.layer.encoding?.x;
+  if (x?.bin === undefined) return undefined;
+  const bins = resolveLineBins(
+    dataset.values,
+    consumer.layer,
+    findScale(program, x.scale)
+  );
+  return { xBinBoundaries: bins.boundaries };
+}
+
+export function resolveMarkFamilyConsumerValues(program, consumer, dataset) {
   if (consumer.layer.mark?.type === "rect") {
     return {
       matched: true,
@@ -25,10 +38,17 @@ export function resolveMarkFamilyConsumerValues(consumer, dataset) {
   }
   if (
     consumer.layer.mark?.type === "line" &&
-    (isAggregate(consumer.layer.encoding?.y?.aggregate) ||
+    ((consumer.layer.encoding?.x !== undefined &&
+      isAggregate(consumer.layer.encoding?.y?.aggregate) &&
+      !(consumer.channel === "x" &&
+        consumer.layer.encoding?.x?.bin !== undefined)) ||
       consumer.channel === "strokeWidth")
   ) {
-    const derived = deriveLineSeries(dataset.values, consumer.layer);
+    const derived = deriveLineSeries(
+      dataset.values,
+      consumer.layer,
+      lineDerivationOptions(program, consumer, dataset)
+    );
     return {
       matched: true,
       values: consumer.channel === "strokeWidth"

package/src/actions/scales/consumers/index.js

@@ -35,7 +35,7 @@ export function resolveConsumerValues(program, consumer) {
   if (isDirectCategoricalConsumer(consumer)) {
     return readConsumerFieldValues(program, consumer, dataset, scale);
   }
-  const family = resolveMarkFamilyConsumerValues(consumer, dataset);
+  const family = resolveMarkFamilyConsumerValues(program, consumer, dataset);
   return family.matched
     ? family.values
     : readConsumerFieldValues(program, consumer, dataset, scale);

package/src/actions/scales/consumers/seriesLayout.js

@@ -1,4 +1,5 @@
 import { deriveBarAggregates } from "../../../grammar/bars/aggregate.js";
+import { validateGeneratedItemLimit } from "../../../core/validation.js";
 import {
   BAR_GRAINS,
   resolveBarChannels,
@@ -72,6 +73,10 @@ function resolveHistogramPartitions(program, consumer) {
   const colorScale = findScale(program, colorEncoding.scale);
   const colorValues = readNominalField(dataset.values, colorEncoding.field);
   const colorDomain = resolveOrdinalDomain(colorScale.domain, colorValues);
+  validateGeneratedItemLimit(
+    (bins.boundaries.length - 1) * colorDomain.length,
+    "Histogram layout cell count"
+  );
   const colorIndex = new Map(colorDomain.map((value, index) => [value, index]));
   const partitions = bins.boundaries.slice(0, -1).map(() =>
     colorDomain.map(() => 0)
@@ -109,6 +114,10 @@ function resolveAggregatePartitions(program, consumer) {
   const colorScale = findScale(program, colorEncoding.scale);
   const colorValues = readNominalField(dataset.values, colorEncoding.field);
   const colorDomain = resolveOrdinalDomain(colorScale.domain, colorValues);
+  validateGeneratedItemLimit(
+    categoryDomain.length * colorDomain.length,
+    "Aggregate layout cell count"
+  );
   const cells = new Map(derived.values.map(value => [
     JSON.stringify([value[channels.category], value.color]),
     value[channels.measure]
@@ -131,6 +140,10 @@ function resolveAreaPartitions(program, consumer) {
     layer.encoding?.x !== undefined
   ) {
     const derived = deriveCenteredAreaSeries(dataset.values, layer);
+    validateGeneratedItemLimit(
+      derived.series[0].values.length * derived.series.length,
+      "Area layout cell count"
+    );
     return Array.from({ length: derived.series[0].values.length }, (_, index) =>
       derived.series.map(series => series.values[index].y)
     );
@@ -142,6 +155,10 @@ function resolveAreaPartitions(program, consumer) {
   if (derived.series.some(series => series.values.length !== sampleCount)) {
     throw new Error(`Area mark "${layer.id}" requires aligned layout samples.`);
   }
+  validateGeneratedItemLimit(
+    sampleCount * derived.series.length,
+    "Area layout cell count"
+  );
   return Array.from({ length: sampleCount }, (_, index) =>
     derived.series.map(series => series.values[index].y)
   );