ggaction 0.0.13 → 0.0.16

package/src/actions/facets/derive.js

@@ -4,10 +4,14 @@ import { readQuantitativeField } from "../../grammar/scales/index.js";
 import { BAR_GRAINS, resolveBarGrain } from "../../grammar/bars/policy.js";
 import { resolveFacetScaleDomains } from "../../grammar/facets/scales.js";
 import {
+  applyLayerEmptyDataView,
   applyMaterializationPlan,
   planScaleGuideRematerialization
 } from "../../materialization/dependencies.js";
-import { getMarkMaterializationStep } from "../../materialization/marks/index.js";
+import {
+  getLayerScaleIds,
+  getMarkMaterializationStep
+} from "../../materialization/marks/index.js";
 import { buildMaterializationPlan } from "../../materialization/planner.js";
 import { requireDataset } from "../../selectors/datasets.js";
 import { requireLayer } from "../../selectors/layers.js";
@@ -56,7 +60,7 @@ function applySharedHistogramBoundaries(program, layerId, boundaries) {
   });
 }
 
-function deriveCellProgram(
+function buildFacetCellCandidate(
   base,
   definition,
   cell,
@@ -81,12 +85,6 @@ function deriveCellProgram(
     });
     source = id;
   }
-  if (requireDataset(child, cell.data).values.length === 0) {
-    while (child.semanticSpec.layers.length > 0) {
-      child = child.removeMark({ target: child.semanticSpec.layers[0].id });
-    }
-    return child;
-  }
   const datasets = new Map([[definition.data, cell.data]]);
   for (const replay of definition.dependencies.replay) {
     const source = datasets.get(replay.source);
@@ -108,6 +106,7 @@ function deriveCellProgram(
     });
     datasets.set(replay.id, id);
   }
+  const reboundData = new Map();
   for (const layer of definition.dependencies.layers) {
     const data = datasets.get(layer.data);
     if (data === undefined) {
@@ -115,6 +114,14 @@ function deriveCellProgram(
         `Facet layer "${layer.id}" has no replayed dataset in cell "${cell.id}".`
       );
     }
+    reboundData.set(layer.id, data);
+    const statistical = child.markConfigs[layer.id]?.statisticalReference;
+    if (statistical !== undefined) {
+      child = child._withMarkConfig(layer.id, {
+        ...child.markConfigs[layer.id],
+        statisticalReference: { ...statistical, dataId: data }
+      });
+    }
     child = child.rebindLayerData({ id: layer.id, data });
     child = applySharedHistogramBoundaries(
       child,
@@ -134,20 +141,35 @@ function deriveCellProgram(
     }
     child = child.rebindGradientPlotProfile({ id, profile, source });
   }
-  const scaleIds = [...new Set(child.semanticSpec.layers.flatMap(layer =>
-    Object.values(layer.encoding ?? {})
-      .map(encoding => encoding?.scale)
-      .filter(id => id !== undefined)
-  ))];
-  return applyMaterializationPlan(child, buildMaterializationPlan({
+  const primaryLayers = definition.dependencies.primaryLayers ??
+    definition.dependencies.layers.map(layer => layer.id);
+  const populated = primaryLayers.some(id => {
+    const data = reboundData.get(id);
+    return data !== undefined && requireDataset(child, data).values.length > 0;
+  });
+  if (!populated) {
+    for (const layer of definition.dependencies.layers) {
+      child = applyLayerEmptyDataView(child, layer.id);
+    }
+    return { program: child, populated: false };
+  }
+  const scaleIds = [...new Set(child.semanticSpec.layers.flatMap(getLayerScaleIds))];
+  const program = applyMaterializationPlan(child, buildMaterializationPlan({
     scales: scaleIds.map(id => ({
       op: "rematerializeScale",
       args: { id, guides: false, marks: false }
     }))
   }));
+  return { program, populated: true };
 }
 
-function applyResolvedDomains(program, childId, resolution, baseResolved) {
+function applyResolvedDomains(
+  program,
+  childId,
+  resolution,
+  baseResolved,
+  { marks: materializeMarks = true } = {}
+) {
   let next = program;
   for (const [id, scaleResolution] of Object.entries(resolution.scales)) {
     const current = next.resolvedScales[id];
@@ -157,19 +179,22 @@ function applyResolvedDomains(program, childId, resolution, baseResolved) {
     const shared = scaleResolution.policy === "shared"
       ? baseResolved?.[id]
       : undefined;
+    const semanticDomain = findSemanticScale(next, id)?.domain;
+    const domain = scaleResolution.childDomains[childId] ??
+      scaleResolution.domain ?? semanticDomain;
     next = next._withResolvedScale(id, {
       ...current,
       ...shared,
-      domain: scaleResolution.childDomains[childId]
+      domain
     });
   }
-  const marks = next.semanticSpec.layers.flatMap(layer => {
+  const marks = materializeMarks ? next.semanticSpec.layers.flatMap(layer => {
     const step = getMarkMaterializationStep(next, layer);
     if (step === undefined) return [];
-    return ["bar", "line", "area"].includes(layer.mark?.type)
+    return ["bar", "line", "area", "arc"].includes(layer.mark?.type)
       ? [{ ...step, args: { ...step.args, scales: false } }]
       : [step];
-  });
+  }) : [];
   const guides = Object.keys(resolution.scales).flatMap(id =>
     planScaleGuideRematerialization(next, id)
   );
@@ -179,6 +204,22 @@ function applyResolvedDomains(program, childId, resolution, baseResolved) {
   );
 }
 
+function materializeFacetCell(
+  child,
+  childId,
+  resolution,
+  baseResolved,
+  populated
+) {
+  return applyResolvedDomains(
+    child,
+    childId,
+    resolution,
+    baseResolved,
+    { marks: populated }
+  );
+}
+
 export function deriveFacetChildren(
   base,
   definition,
@@ -196,32 +237,49 @@ export function deriveFacetChildren(
   const bins = xPolicy === "shared"
     ? sharedHistogramBoundaries(template)
     : new Map();
-  const independentlyResolved = Object.fromEntries(definition.cells.map(cell => [
+  const candidates = Object.fromEntries(definition.cells.map(cell => [
     cell.id,
-    deriveCellProgram(template, definition, cell, bins, scales)
+    buildFacetCellCandidate(template, definition, cell, bins, scales)
   ]));
+  const independentlyResolved = Object.fromEntries(Object.entries(candidates).map(
+    ([id, candidate]) => [id, candidate.program]
+  ));
+  const populatedIds = new Set(Object.entries(candidates).flatMap(
+    ([id, candidate]) => candidate.populated ? [id] : []
+  ));
   return resolveFacetChildrenScales(
     template,
     definition.cells.map(cell => cell.id),
     independentlyResolved,
     scales,
-    closeInheritedAction
+    closeInheritedAction,
+    populatedIds
   );
 }
 
+function closeInheritedActions(program) {
+  let closed = program;
+  while (closed.actionStack.length > 0) closed = closed._exitAction();
+  return closed;
+}
+
 export function resolveFacetChildrenScales(
   template,
   cellIds,
   independentlyResolved,
   scales = {},
-  closeInheritedAction = false
+  closeInheritedAction = false,
+  populatedIds = undefined
 ) {
   const populated = Object.fromEntries(cellIds.flatMap(id => {
     const child = independentlyResolved[id];
     if (child === undefined) {
       throw new Error(`Facet derivation is missing child "${id}".`);
     }
-    return child.semanticSpec.layers.length > 0 ? [[id, child]] : [];
+    const populated = populatedIds === undefined
+      ? child.semanticSpec.layers.length > 0
+      : populatedIds.has(id);
+    return populated ? [[id, child]] : [];
   }));
   if (Object.keys(populated).length === 0) {
     throw new Error("Facet derivation requires at least one populated cell.");
@@ -235,19 +293,32 @@ export function resolveFacetChildrenScales(
     scales,
     template.resolvedScales
   );
+  const emptyIds = cellIds.filter(id => !Object.hasOwn(populated, id));
+  const scalesById = new Map(template.semanticSpec.scales.map(scale => [scale.id, scale]));
+  for (const childId of emptyIds) {
+    const unresolved = Object.entries(resolution.scales).find(([id, value]) =>
+      value.policy === "independent" && scalesById.get(id)?.domain === "auto"
+    );
+    if (unresolved !== undefined) {
+      throw new Error(
+        `Facet child "${childId}" cannot resolve independent scale "${unresolved[0]}" from an empty partition.`
+      );
+    }
+  }
   const resolvedChildren = Object.fromEntries(
     cellIds.map(id => {
       const child = independentlyResolved[id];
       if (child.semanticSpec.layers.length === 0) {
-        return [id, closeInheritedAction ? child._exitAction() : child];
+        return [id, closeInheritedAction ? closeInheritedActions(child) : child];
       }
-      const resolved = applyResolvedDomains(
+      const resolved = materializeFacetCell(
         child,
         id,
         resolution,
-        template.resolvedScales
+        template.resolvedScales,
+        Object.hasOwn(populated, id)
       );
-      return [id, closeInheritedAction ? resolved._exitAction() : resolved];
+      return [id, closeInheritedAction ? closeInheritedActions(resolved) : resolved];
     })
   );
   const firstPopulatedId = Object.keys(populated)[0];

package/src/actions/facets/guides.js

@@ -1,16 +1,15 @@
-import { action } from "../../core/action.js";
-import { validateKeys } from "../../core/validation.js";
+import { closedAction } from "../../core/action.js";
+
 import { applyFacetGuideComposition } from
   "../../materialization/facetGuides/index.js";
 
-export const composeFacetGuides = action(
+export const composeFacetGuides = /* @__PURE__ */ closedAction(
   {
     op: "composeFacetGuides",
     description: "Apply outer-axis ownership and promote shared facet legends.",
     scope: "composition"
-  },
+  }, ["layout", "plot"],
   function ({ layout, plot } = {}) {
-    validateKeys({ layout, plot }, ["layout", "plot"], "composeFacetGuides");
     return applyFacetGuideComposition(this, { layout, plot });
   }
 );

package/src/actions/facets/replay.js

@@ -1,7 +1,7 @@
-import { action } from "../../core/action.js";
+import { closedAction } from "../../core/action.js";
 import { isPlainObject } from "../../core/immutable.js";
 import { validateUserId } from "../../core/identifiers.js";
-import { validateKeys } from "../../core/validation.js";
+
 import { findTransformPolicy } from "../../grammar/transforms.js";
 
 const REPLAY_OPTIONS = Object.freeze(["id", "source", "transform"]);
@@ -22,13 +22,12 @@ function requestedTransform(transform) {
   };
 }
 
-export const replayDerivedData = action(
+export const replayDerivedData = /* @__PURE__ */ closedAction(
   {
     op: "replayDerivedData",
     description: "Replay one stored derived-data transform for a facet cell."
-  },
+  }, REPLAY_OPTIONS,
   function (args = {}) {
-    validateKeys(args, REPLAY_OPTIONS, "replayDerivedData");
     const id = validateUserId(args.id, "Facet replay dataset id");
     const source = validateUserId(args.source, "Facet replay source id");
     const resolved = requestedTransform(args.transform);

package/src/actions/gradientPlots/components.js

@@ -1,7 +1,11 @@
 import { assertGuideOptions, guideConflict } from "../guides/reuse.js";
-import { action } from "../../core/action.js";
+import { action, closedAction } from "../../core/action.js";
 import { validateKeys } from "../../core/validation.js";
 import { GRADIENT_PROFILE_FIELDS } from "../../grammar/gradientProfile.js";
+import {
+  requestedStrokeDetails,
+  STROKE_STYLE_PROPERTIES
+} from "../../grammar/strokeStyle.js";
 import { resolveGraphicBounds } from "../../layout/canvas.js";
 import { findLayer } from "../../selectors/layers.js";
 import { createDensityLegendPaint } from "./paint.js";
@@ -9,21 +13,24 @@ import { createDensityLegendPaint } from "./paint.js";
 const CENTER_OPTIONS = Object.freeze([
   "id", "owner", "data", "category", "categoryType", "coordinate",
   "categoryScale", "measureScale", "orientation", "size", "stroke",
-  "strokeWidth"
+  "strokeWidth", ...STROKE_STYLE_PROPERTIES
 ]);
 const LEGEND_OPTIONS = Object.freeze(["owner", "title", "position"]);
 
-export const createGradientPlotCenter = action(
+export const createGradientPlotCenter = /* @__PURE__ */ closedAction(
   {
     op: "createGradientPlotCenter",
     description: "Create the optional center rule for one gradient plot."
-  },
+  }, CENTER_OPTIONS,
   function (args = {}) {
-    validateKeys(args, CENTER_OPTIONS, "createGradientPlotCenter");
     const categoryAction = args.orientation === "vertical" ? "encodeX" : "encodeY";
     const measureAction = args.orientation === "vertical" ? "encodeY" : "encodeX";
     const spanOrientation = args.orientation === "vertical" ? "horizontal" : "vertical";
-    let next = this.createRuleMark({ id: args.id, data: args.data });
+    let next = this.createRuleMark({
+      id: args.id,
+      data: args.data,
+      ...requestedStrokeDetails(args, "createGradientPlotCenter")
+    });
     next = next[categoryAction]({
       target: args.id,
       field: args.category,
@@ -74,7 +81,7 @@ function editProperties(program, target, properties) {
   return next;
 }
 
-export const rematerializeGradientPlotLegend = action(
+export const rematerializeGradientPlotLegend = /* @__PURE__ */ action(
   {
     op: "rematerializeGradientPlotLegend",
     description: "Rematerialize one gradient plot density legend."
@@ -152,7 +159,7 @@ export function fulfillGradientPlotLegend(program, args) {
   return program;
 }
 
-export const createGradientPlotLegend = action(
+export const createGradientPlotLegend = /* @__PURE__ */ action(
   {
     op: "createGradientPlotLegend",
     description: "Create the neutral density legend owned by one gradient plot."

package/src/actions/gradientPlots/create.js

@@ -1,5 +1,5 @@
-import { action } from "../../core/action.js";
-import { validateKeys } from "../../core/validation.js";
+import { closedAction } from "../../core/action.js";
+
 import { findDataset } from "../../selectors/datasets.js";
 import { findSemanticScale } from "../../selectors/scales.js";
 import {
@@ -18,13 +18,12 @@ import {
   resolveGradientSourceLayer
 } from "./resolve.js";
 
-export const createGradientPlot = action(
+export const createGradientPlot = /* @__PURE__ */ closedAction(
   {
     op: "createGradientPlot",
     description: "Create a categorical density gradient plot."
-  },
+  }, GRADIENT_PLOT_OPTIONS,
   function (args = {}) {
-    validateKeys(args, GRADIENT_PLOT_OPTIONS, "createGradientPlot");
     const id = resolveGradientPlotId(this, args.id);
     const source = resolveGradientSourceLayer(this, args.target);
     const data = args.data ?? source?.data ?? this.context.currentData ??

package/src/actions/gradientPlots/edit.js

@@ -1,12 +1,13 @@
-import { action } from "../../core/action.js";
+import { closedAction } from "../../core/action.js";
 import { isPlainObject } from "../../core/immutable.js";
 import { validateUserId } from "../../core/identifiers.js";
-import { validateKeys } from "../../core/validation.js";
+
 import { planDerivedDataRevision } from "../../materialization/dataProvenance.js";
 import { findDataset } from "../../selectors/datasets.js";
 import { findLayer } from "../../selectors/layers.js";
 import { removeOwnedMark } from "../marks/remove.js";
 import { GRADIENT_PROFILE_FIELDS } from "../../grammar/gradientProfile.js";
+import { requestedStrokeDetails } from "../../grammar/strokeStyle.js";
 import { removeGradientPlotLegend } from "./components.js";
 import {
   resolveDistributionRoles,
@@ -40,6 +41,13 @@ function removeCenter(program, id) {
   return removeOwnedMark(program, id, true);
 }
 
+function editCenterStrokeDetails(program, id, center) {
+  const details = requestedStrokeDetails(center, "Gradient plot center");
+  return Object.keys(details).length === 0
+    ? program
+    : program.editRuleMark({ target: id, ...details });
+}
+
 function roleCandidate(program, owner, current, args) {
   return {
     source: Object.hasOwn(args, "data")
@@ -102,13 +110,12 @@ function updateGradientPositions(program, owner, current, candidate, hasCenter)
   );
 }
 
-export const editGradientPlot = action(
+export const editGradientPlot = /* @__PURE__ */ closedAction(
   {
     op: "editGradientPlot",
     description: "Edit one stable categorical gradient plot."
-  },
+  }, OPTIONS,
   function (args = {}) {
-    validateKeys(args, OPTIONS, "editGradientPlot");
     if (!OPTIONS.slice(1).some(key => Object.hasOwn(args, key))) {
       throw new Error("editGradientPlot requires at least one gradient-plot option.");
     }
@@ -219,10 +226,11 @@ export const editGradientPlot = action(
             orientation: candidate.orientation,
             size: spanSize,
             stroke: center.stroke,
-            strokeWidth: center.strokeWidth
+            strokeWidth: center.strokeWidth,
+            ...requestedStrokeDetails(center, "Gradient plot center")
           });
         } else if (retainedCenter) {
-          next = next
+          next = editCenterStrokeDetails(next, current.centerId, center)
             .encodeStroke({ target: current.centerId, value: center.stroke })
             .encodeStrokeWidth({
               target: current.centerId,
@@ -291,10 +299,11 @@ export const editGradientPlot = action(
         orientation: current.orientation,
         size: 1,
         stroke: center.stroke,
-        strokeWidth: center.strokeWidth
+        strokeWidth: center.strokeWidth,
+        ...requestedStrokeDetails(center, "Gradient plot center")
       });
     } else if (center !== false) {
-      next = next
+      next = editCenterStrokeDetails(next, current.centerId, center)
         .encodeStroke({ target: current.centerId, value: center.stroke })
         .encodeStrokeWidth({ target: current.centerId, value: center.strokeWidth });
     }

package/src/actions/gradientPlots/materialize.js

@@ -4,6 +4,7 @@ import { action } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
 import { isPlainObject } from "../../core/immutable.js";
 import { GRADIENT_PROFILE_FIELDS } from "../../grammar/gradientProfile.js";
+import { requestedStrokeDetails } from "../../grammar/strokeStyle.js";
 import {
   mapContinuousScaleValues,
   mapOrdinalPositionValues
@@ -122,7 +123,7 @@ function bodyItems(program, layer, dataset, config) {
   });
 }
 
-export const materializeGradientPlotFill = action(
+export const materializeGradientPlotFill = /* @__PURE__ */ action(
   {
     op: "materializeGradientPlotFill",
     description: "Materialize categorical density profiles as gradient strips."
@@ -169,7 +170,7 @@ export const materializeGradientPlotFill = action(
   }
 );
 
-export const materializeGradientPlot = action(
+export const materializeGradientPlot = /* @__PURE__ */ action(
   {
     op: "materializeGradientPlot",
     description: "Materialize one complete categorical gradient plot."
@@ -248,7 +249,8 @@ export const materializeGradientPlot = action(
         orientation,
         size: Math.max(1, categoryScale.bandwidth * config.width.band - 16),
         stroke: config.center.stroke,
-        strokeWidth: config.center.strokeWidth
+        strokeWidth: config.center.strokeWidth,
+        ...requestedStrokeDetails(config.center, "Gradient plot center")
       });
     }
     const guides = config.guides;

package/src/actions/gradientPlots/options.js

@@ -5,6 +5,10 @@ import {
   validateUnitInterval
 } from "../../core/validation.js";
 import { normalizePalette } from "../../grammar/palettes.js";
+import {
+  requestedStrokeDetails,
+  STROKE_STYLE_PROPERTIES
+} from "../../grammar/strokeStyle.js";
 
 export const GRADIENT_PLOT_OPTIONS = Object.freeze([
   "id", "target", "data", "x", "y", "coordinate", "density", "width",
@@ -90,7 +94,7 @@ export function resolveGradientCenter(
   if (value === false) return false;
   const options = plain(
     value,
-    ["type", "stroke", "strokeWidth"],
+    ["type", "stroke", "strokeWidth", ...STROKE_STYLE_PROPERTIES],
     "center",
     operation
   );
@@ -108,7 +112,11 @@ export function resolveGradientCenter(
       : validateNonNegativeFinite(
           options.strokeWidth,
           `${operation} center.strokeWidth`
-        )
+        ),
+    ...requestedStrokeDetails(
+      { ...(previous ?? {}), ...options },
+      `${operation} center`
+    )
   });
 }
 

package/src/actions/gradientPlots/rebind.js

@@ -1,18 +1,17 @@
-import { action } from "../../core/action.js";
+import { closedAction } 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";
 
 const OPTIONS = Object.freeze(["id", "profile", "source"]);
 
-export const rebindGradientPlotProfile = action(
+export const rebindGradientPlotProfile = /* @__PURE__ */ closedAction(
   {
     op: "rebindGradientPlotProfile",
     description: "Rebind one gradient plot to a replayed profile revision."
-  },
+  }, OPTIONS,
   function (args = {}) {
-    validateKeys(args, OPTIONS, "rebindGradientPlotProfile");
     const id = validateUserId(args.id, "Gradient-plot id");
     const profileId = validateUserId(
       args.profile,

package/src/actions/guides/applicability.js

@@ -51,6 +51,8 @@ export function hasInferableLegend(program, layers = program.semanticSpec.layers
       isOpacityLegendLayer(layer) ||
       (layer.mark?.type === "point" &&
         layer.encoding?.size?.scale !== undefined) ||
+      (layer.mark?.type === "point" &&
+        layer.encoding?.stroke?.scale !== undefined) ||
       (layer.mark?.type === "point" &&
         layer.encoding?.color?.scale !== undefined &&
         (layer.encoding?.shape?.scale !== undefined ||
@@ -58,11 +60,15 @@ export function hasInferableLegend(program, layers = program.semanticSpec.layers
             findSemanticScale(program, layer.encoding.color.scale)?.type
           ))) ||
       (layer.mark?.type === "line" &&
-        ["color", "strokeDash"].some(
+        ["color", "stroke", "strokeDash"].some(
           channel => layer.encoding?.[channel]?.scale !== undefined
         )) ||
       (["bar", "area", "arc", "rect"].includes(layer.mark?.type) &&
-        layer.encoding?.color?.scale !== undefined)
+        ["color", "stroke"].some(
+          channel => layer.encoding?.[channel]?.scale !== undefined
+        )) ||
+      (["rule", "tick"].includes(layer.mark?.type) &&
+        layer.encoding?.stroke?.scale !== undefined)
     )
   );
 }

package/src/actions/guides/axes/axes.js

@@ -38,6 +38,7 @@ export function validateAxesArgs(args) {
   if (!COORDINATE_API_TYPES.has(type)) {
     throw new Error(`Unknown createAxes coordinate type "${type}".`);
   }
+  if (coordinate.id !== undefined) validateUserId(coordinate.id, "Coordinate id");
 
   return coordinate;
 }
@@ -121,7 +122,7 @@ function resolveCoordinate(program, descriptor, cartesianLayers) {
   }
 
   if (existing.type !== "cartesian") {
-    throw new Error("createAxes does not yet support Polar axes.");
+    throw new Error("createAxes x/y options require a Cartesian coordinate.");
   }
 
   return { id, layers };
@@ -184,10 +185,10 @@ function resolveAxisArgs(layers, channel, option) {
   return { ...args, scale };
 }
 
-const createAxes = action(
+const createAxes = /* @__PURE__ */ action(
   {
     op: "createAxes",
-    description: "Read a semantic coordinate and create its Cartesian axes."
+    description: "Read a stored coordinate and create its applicable axes."
   },
   function (args = {}) {
     const coordinateDescriptor = validateAxesArgs(args);
@@ -197,6 +198,16 @@ const createAxes = action(
     const requestedCoordinateType = coordinateDescriptor.id === undefined
       ? undefined
       : findCoordinate(this, coordinateDescriptor.id)?.type;
+    if (coordinateDescriptor.id !== undefined) {
+      if (requestedCoordinateType === undefined) {
+        throw new Error(`Unknown coordinate "${coordinateDescriptor.id}".`);
+      }
+      if (coordinateDescriptor.type !== undefined &&
+          coordinateDescriptor.type !== "auto" &&
+          coordinateDescriptor.type !== requestedCoordinateType) {
+        throw new Error(`Coordinate "${coordinateDescriptor.id}" has type "${requestedCoordinateType}", not "${coordinateDescriptor.type}".`);
+      }
+    }
     const explicitlyPolar = coordinateDescriptor.type === "polar" ||
       requestedCoordinateType === "polar" ||
       args.theta !== undefined || args.radius !== undefined;
@@ -206,6 +217,10 @@ const createAxes = action(
       (cartesianLayers.length === 0 && polarLayers.length === 0) ||
       explicitlyParallel
     )) {
+      if (coordinateDescriptor.type !== undefined &&
+          !["auto", "parallel"].includes(coordinateDescriptor.type)) {
+        throw new Error("createAxes coordinate type conflicts with Parallel encodings.");
+      }
       if (
         args.x !== undefined || args.y !== undefined ||
         args.theta !== undefined || args.radius !== undefined
@@ -231,7 +246,8 @@ const createAxes = action(
     }
     if (polarLayers.length > 0 &&
         (cartesianLayers.length === 0 || explicitlyPolar)) {
-      if (coordinateDescriptor.type === "cartesian") {
+      if (coordinateDescriptor.type !== undefined &&
+          !["auto", "polar"].includes(coordinateDescriptor.type)) {
         throw new Error("createAxes coordinate type conflicts with Polar encodings.");
       }
       if (args.x !== undefined || args.y !== undefined) {
@@ -263,6 +279,9 @@ const createAxes = action(
       }
       return polarProgram;
     }
+    if (args.theta !== undefined || args.radius !== undefined) {
+      throw new Error("createAxes theta/radius options require Polar encodings.");
+    }
     const coordinate = resolveCoordinate(
       this,
       coordinateDescriptor,

package/src/actions/guides/axes/axis.js

@@ -122,8 +122,8 @@ function makeCreateAxis(channel) {
   );
 }
 
-const createXAxis = makeCreateAxis("x");
-const createYAxis = makeCreateAxis("y");
+const createXAxis = /* @__PURE__ */ makeCreateAxis("x");
+const createYAxis = /* @__PURE__ */ makeCreateAxis("y");
 
 export function registerAxisActions(Class) {
   Class.prototype.createXAxis = createXAxis;

package/src/actions/guides/axes/edit.js

@@ -164,8 +164,8 @@ function makeEditAxis(channel) {
   );
 }
 
-const editXAxis = makeEditAxis("x");
-const editYAxis = makeEditAxis("y");
+const editXAxis = /* @__PURE__ */ makeEditAxis("x");
+const editYAxis = /* @__PURE__ */ makeEditAxis("y");
 
 export function registerCompleteAxisEditActions(ProgramClass) {
   ProgramClass.prototype.editXAxis = editXAxis;