ggaction 0.0.17 → 0.0.19

package/src/actions/encodings/remove.js

@@ -1,3 +1,4 @@
+import { cartesianAxisOwners, axisTargetArgs } from "../../selectors/axes.js";
 import { closedAction } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
 
@@ -26,6 +27,7 @@ import { findDataset } from "../../selectors/datasets.js";
 import { assertPathGroupCompatible, validatePathGroupAppearance } from "../../materialization/marks/grouping.js";
 import { assertEncodingSelectionCompatibility } from "../../materialization/selection/compatibility.js";
 import { planLegendBlockTransitions } from "../guides/legends/transition.js";
+import { withGuideLayoutValidation } from "../../materialization/guides/layout.js";
 
 const OPTIONS = Object.freeze(["target", "channel"]);
 const REMOVABLE_CHANNELS = Object.freeze([
@@ -40,9 +42,9 @@ const REMOVE_AXIS = Object.freeze({
   radius: "removeRadialAxis"
 });
 const SPECIALIZED_LEGEND_KIND = Object.freeze({
-  color: Object.freeze(["gradient", "interval"]),
+  color: Object.freeze(["gradient", "interval", "colorSize"]),
   stroke: Object.freeze(["strokeGradient", "strokeInterval"]),
-  size: Object.freeze(["size"]),
+  size: Object.freeze(["size", "colorSize"]),
   opacity: Object.freeze(["opacity"]),
   strokeWidth: Object.freeze(["strokeWidth"])
 });
@@ -143,10 +145,14 @@ function cleanupPositionGuides(program, removed) {
     ) {
       continue;
     }
-    const axis = next.semanticSpec.guides.axis?.[definition.guideChannel];
-    if (axis?.scale === scale) {
-      next = next[REMOVE_AXIS[definition.guideChannel]]({
-        scale,
+    const owners = ["x", "y"].includes(definition.guideChannel)
+      ? cartesianAxisOwners(next).filter(owner => owner.channel === definition.guideChannel)
+      : [{ id: definition.guideChannel, channel: definition.guideChannel,
+          semantic: next.semanticSpec.guides.axis?.[definition.guideChannel] }];
+    for (const owner of owners) {
+      const axis = owner.semantic;
+      if (axis?.scale === scale) next = next[REMOVE_AXIS[definition.guideChannel]]({
+        ...axisTargetArgs(owner.id, owner.channel), scale,
         ...(axis.coordinate === undefined ? {} : { coordinate: axis.coordinate })
       });
     }
@@ -208,7 +214,7 @@ export const removeEncoding = /* @__PURE__ */ closedAction(
     op: "removeEncoding",
     description: "Remove one semantic encoding and its owned materialized state."
   }, OPTIONS,
-  function (args = {}) {
+  withGuideLayoutValidation(function (args = {}) {
     if (!REMOVABLE_CHANNELS.includes(args.channel)) {
       throw new Error(
         `Unsupported removable encoding channel "${args.channel}".`
@@ -259,7 +265,7 @@ export const removeEncoding = /* @__PURE__ */ closedAction(
     next = cleanupLegends(next, layer.id, channels);
     next = cleanupPositionGuides(next, removedPositions);
     return applyDetachedScaleRematerialization(rematerializeTarget(next, layer.id), [layer]);
-  }
+  })
 );
 
 export function registerEncodingRemovalAction(ProgramClass) {

package/src/actions/encodings/seriesLayout.js

@@ -48,6 +48,7 @@ export const layoutSeries = /* @__PURE__ */ action({ op: "layoutSeries", descrip
     if (grain === undefined || encoding.x?.scale === undefined || encoding.y?.scale === undefined) throw new Error("Series layout requires a complete bar.");
     if (mode === "center") throw new Error("Centered bars are not supported.");
     if (grain === BAR_GRAINS.ranged && mode !== "overlay") throw new Error("Ranged bars support only overlay layout.");
+    if (grain === BAR_GRAINS.centered && mode !== "overlay") throw new Error("Numeric-center bars support only overlay layout.");
     if (grain === BAR_GRAINS.aggregate) deriveBarAggregates(dataset.values, updated);
     if (mode === "group" && grain === BAR_GRAINS.aggregate) {
       if (encoding.group === undefined) throw new Error("Grouped bars require a group encoding.");

package/src/actions/encodings/shared.js

@@ -1,3 +1,4 @@
+import { cartesianAxisOwners } from "../../selectors/axes.js";
 import { isSourceOwnedText } from "../../grammar/text.js";
 import { validateUserId } from "../../core/identifiers.js";
 import { findDataset } from "../../selectors/datasets.js";
@@ -80,7 +81,7 @@ export function applyEncodingScale(
   for (const property of [
     "domain", "range", "nice", "zero", "clamp", "reverse",
     "base", "exponent", "constant", "paddingInner", "paddingOuter",
-    "padding", "align", "unknown", "interpolate", "radialMapping"
+    "padding", "align", "unknown", "interpolate", "whitePoint", "gamma", "radialMapping"
   ]) {
     if (Object.hasOwn(options, property)) patch[property] = definition[property];
   }
@@ -102,26 +103,26 @@ export function rebindPositionGuides(
   if (definition?.guideChannel === undefined) return program;
   if (previousScale === undefined || previousScale === nextScale) return program;
 
-  const axis = program.semanticSpec.guides.axis?.[definition.guideChannel];
+  const owners = ["x", "y"].includes(definition.guideChannel)
+    ? cartesianAxisOwners(program).filter(owner => owner.channel === definition.guideChannel)
+    : [{ id: definition.guideChannel, semantic: program.semanticSpec.guides.axis?.[definition.guideChannel] }];
   const direction = definition.gridDirection;
   const grid = program.semanticSpec.guides.grid?.[direction];
-  const ownsAxis = axis?.scale === previousScale;
-  const refreshesReboundAxis = axis?.scale === nextScale;
   const ownsGrid = grid?.scale === previousScale;
-  if (!ownsAxis && !ownsGrid && !refreshesReboundAxis) return program;
-
-  const remaining = program.semanticSpec.layers.some(layer =>
-    layer.id !== target && !isSourceOwnedText(layer) && layer.encoding?.[channel]?.scale === previousScale
-  );
-  if ((ownsAxis || ownsGrid) && remaining) {
-    throw new Error(
-      `Cannot rebind ${channel} guides from shared scale "${previousScale}" while it has other consumers.`
-    );
+  const affected = owners.filter(owner => [previousScale, nextScale].includes(owner.semantic?.scale));
+  if (!affected.length && !ownsGrid) return program;
+  const remaining = program.semanticSpec.layers.some(layer => layer.id !== target &&
+    !isSourceOwnedText(layer) && layer.encoding?.[channel]?.scale === previousScale);
+  if ((affected.some(owner => owner.semantic?.scale === previousScale) || ownsGrid) && remaining) {
+    throw new Error(`Cannot rebind ${channel} guides from shared scale "${previousScale}" while it has other consumers.`);
   }
-
   let next = program;
+  for (const owner of affected) {
+    const axisId = owner.id;
+    const ownsAxis = owner.semantic?.scale === previousScale;
+    const refreshesReboundAxis = owner.semantic?.scale === nextScale;
   if (ownsAxis || refreshesReboundAxis) {
-    const previousAxisConfig = next.guideConfigs.axis?.[definition.guideChannel];
+    const previousAxisConfig = next.guideConfigs.axis?.[axisId];
     const previousTicks = previousAxisConfig?.ticks;
     const previousLabels = previousAxisConfig?.labels;
     const labelsFollowTicks = previousTicks !== undefined &&
@@ -135,13 +136,13 @@ export function rebindPositionGuides(
           ));
     if (ownsAxis) {
       next = next.editSemantic({
-        property: `guide.axis.${definition.guideChannel}.scale`,
+        property: `guide.axis.${axisId}.scale`,
         value: nextScale
       });
       for (const component of ["line", "ticks", "labels", "title"]) {
-        const config = next.guideConfigs.axis?.[definition.guideChannel]?.[component];
+        const config = next.guideConfigs.axis?.[axisId]?.[component];
         if (config?.scale === previousScale) {
-          next = next._withGuideConfig(definition.guideChannel, component, {
+          next = next._withGuideConfig(axisId, component, {
             ...config,
             scale: nextScale
           });
@@ -151,7 +152,7 @@ export function rebindPositionGuides(
     const resolved = next.resolvedScales[nextScale] ??
       findSemanticScale(next, nextScale);
     const discrete = ["ordinal", "band", "point"].includes(resolved?.type);
-    let ticks = next.guideConfigs.axis?.[definition.guideChannel]?.ticks;
+    let ticks = next.guideConfigs.axis?.[axisId]?.ticks;
     if (ticks !== undefined && discrete && ticks.mode !== "values") {
       ticks = {
         ...ticks,
@@ -160,7 +161,7 @@ export function rebindPositionGuides(
         inferredValues: true
       };
       delete ticks.count;
-      next = next._withGuideConfig(definition.guideChannel, "ticks", ticks);
+      next = next._withGuideConfig(axisId, "ticks", ticks);
     } else if (
       ticks !== undefined &&
       !discrete &&
@@ -174,18 +175,18 @@ export function rebindPositionGuides(
         inferredValues: true
       };
       delete ticks.values;
-      next = next._withGuideConfig(definition.guideChannel, "ticks", ticks);
+      next = next._withGuideConfig(axisId, "ticks", ticks);
     } else if (
       ticks !== undefined &&
       discrete &&
       ticks.inferredValues === true
     ) {
       ticks = { ...ticks, values: resolved.domain };
-      next = next._withGuideConfig(definition.guideChannel, "ticks", ticks);
+      next = next._withGuideConfig(axisId, "ticks", ticks);
     }
     if (previousLabels !== undefined && labelsFollowTicks && ticks !== undefined) {
       const labels = {
-        ...next.guideConfigs.axis[definition.guideChannel].labels,
+        ...next.guideConfigs.axis[axisId].labels,
         mode: ticks.mode,
         inferredValues: ticks.inferredValues === true,
         ...(ticks.mode === "values"
@@ -195,12 +196,13 @@ export function rebindPositionGuides(
       if (ticks.mode === "values") delete labels.count;
       else delete labels.values;
       next = next._withGuideConfig(
-        definition.guideChannel,
+        axisId,
         "labels",
         labels
       );
     }
   }
+  }
   if (ownsGrid) {
     next = next
       .editSemantic({

package/src/actions/encodings/text.js

@@ -1,4 +1,5 @@
 import { action } from "../../core/action.js";
+import { schemaField } from "../../grammar/datasetSchema.js";
 import { formatTextValue, validateTextFormat } from "../../grammar/text.js";
 import { normalizeMarkLabelContent, resolveMarkLabelValues } from "../../grammar/markLabels.js";
 import { canMaterializeText } from "../../materialization/marks/index.js";
@@ -14,11 +15,13 @@ import { applyRequestedItemMissingPolicy } from
 
 const OPTIONS = Object.freeze(["target", "field", "value", "content", "normalizeBy", "format"]);
 
-function validateTextField(rows, field, format) {
+function validateTextField(dataset, field, format) {
+  const rows = dataset.values;
   if (typeof field !== "string" || field.length === 0) {
     throw new TypeError("encodeText field must be a non-empty string.");
   }
-  let found = false;
+  let found = rows.length === 0 && dataset.schema !== undefined &&
+    schemaField(dataset.schema, field) !== undefined;
   for (const row of rows) {
     if (!Object.hasOwn(row, field)) continue;
     found = true;
@@ -57,7 +60,7 @@ export const encodeText = /* @__PURE__ */ action(
     const content = hasContent
       ? normalizeMarkLabelContent(findLayer(this, layer.source), args)
       : undefined;
-    if (hasField) validateTextField(dataset.values, args.field, format);
+    if (hasField) validateTextField(dataset, args.field, format);
     else if (hasValue && formatTextValue(args.value, format) === undefined) {
       throw new Error("encodeText value must produce non-empty text.");
     }

package/src/actions/errorBands/create.js

@@ -1,7 +1,7 @@
+import { validateFillPaint } from "../../grammar/paint.js";
 import { editGraphicProperties } from "../primitives/graphicProperties.js";
 import { action, closedAction } from "../../core/action.js";
 import { isPlainObject } from "../../core/immutable.js";
-import { validateNonEmptyString } from "../../core/validation.js";
 import { DEFAULT_COLORS } from "../../theme/defaults.js";
 import { validateCurveInterpolation } from "../../grammar/curveCommands.js";
 import {
@@ -176,7 +176,7 @@ export const createErrorBand = /* @__PURE__ */ closedAction(
     const resolved = resolveErrorBand(this, args);
     const curve = validateCurveInterpolation(args.curve ?? "linear");
     const boundaries = resolveBoundaries(args.boundaries, curve);
-    if (args.fill !== undefined) validateNonEmptyString(args.fill, "Error-band fill");
+    if (args.fill !== undefined) validateFillPaint(args.fill, "Error-band fill");
     let next = createResolvedIntervalData(this, resolved);
     next = next.createAreaMark({
       id: resolved.id,

package/src/actions/errorBands/edit.js

@@ -1,3 +1,4 @@
+import { validateFillPaint } from "../../grammar/paint.js";
 import { currentIntervalRoleArgs, resolveIntervalRoleScales, applyIntervalStatistics } from "../intervals/revision.js";
 import { closedAction } from "../../core/action.js";
 import { isPlainObject } from "../../core/immutable.js";
@@ -333,7 +334,7 @@ export const editErrorBand = /* @__PURE__ */ closedAction(
         if (owner.encoding?.color !== undefined) {
           throw new Error("editErrorBand fill conflicts with a color encoding; remove the color encoding first.");
         }
-        errorBand.fill = validateNonEmptyString(args.fill, "Error-band fill");
+        errorBand.fill = validateFillPaint(args.fill, "Error-band fill");
         config.fill = errorBand.fill;
       }
     }