ggaction 0.0.12 → 0.0.15

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,19 +60,31 @@ function applySharedHistogramBoundaries(program, layerId, boundaries) {
   });
 }
 
-function deriveCellProgram(
+function buildFacetCellCandidate(
   base,
   definition,
   cell,
   histogramBoundaries,
   scales
 ) {
-  let child = base.filterData({
-    id: cell.data,
-    source: definition.data,
+  const filters = cell.filters ?? [{
     field: definition.field,
-    oneOf: [cell.value]
-  });
+    value: cell.value
+  }];
+  let child = base;
+  let source = definition.data;
+  for (const [index, filter] of filters.entries()) {
+    const id = index === filters.length - 1
+      ? cell.data
+      : `${cell.id}-partition-${index + 1}-data`;
+    child = child.filterData({
+      id,
+      source,
+      field: filter.field,
+      oneOf: [filter.value]
+    });
+    source = id;
+  }
   const datasets = new Map([[definition.data, cell.data]]);
   for (const replay of definition.dependencies.replay) {
     const source = datasets.get(replay.source);
@@ -90,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) {
@@ -97,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,
@@ -116,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];
@@ -139,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)
   );
@@ -161,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,
@@ -178,34 +237,89 @@ 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,
+    populatedIds
+  );
+}
+
+export function resolveFacetChildrenScales(
+  template,
+  cellIds,
+  independentlyResolved,
+  scales = {},
+  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}".`);
+    }
+    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.");
+  }
   const resolution = resolveFacetScaleDomains(
     template.semanticSpec,
-    Object.fromEntries(Object.entries(independentlyResolved).map(([id, child]) => [
+    Object.fromEntries(Object.entries(populated).map(([id, child]) => [
       id,
       child.resolvedScales
     ])),
     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(
-    Object.entries(independentlyResolved).map(([id, child]) => {
-      const resolved = applyResolvedDomains(
+    cellIds.map(id => {
+      const child = independentlyResolved[id];
+      if (child.semanticSpec.layers.length === 0) {
+        return [id, closeInheritedAction ? child._exitAction() : child];
+      }
+      const resolved = materializeFacetCell(
         child,
         id,
         resolution,
-        template.resolvedScales
+        template.resolvedScales,
+        Object.hasOwn(populated, id)
       );
       return [id, closeInheritedAction ? resolved._exitAction() : resolved];
     })
   );
+  const firstPopulatedId = Object.keys(populated)[0];
   const sharedScales = Object.fromEntries(
     Object.entries(resolution.scales)
       .filter(([, value]) => value.policy === "shared")
-      .map(([id]) => [id, resolvedChildren[definition.cells[0].id].resolvedScales[id]])
+      .map(([id]) => [id, resolvedChildren[firstPopulatedId].resolvedScales[id]])
   );
   return freezeOwned({
     children: freezeOwned(resolvedChildren),

package/src/actions/gradientPlots/components.js

@@ -1,6 +1,11 @@
+import { assertGuideOptions, guideConflict } from "../guides/reuse.js";
 import { action } 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";
@@ -8,7 +13,7 @@ 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"]);
 
@@ -22,7 +27,11 @@ export const createGradientPlotCenter = action(
     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,
@@ -120,23 +129,44 @@ export const rematerializeGradientPlotLegend = action(
   }
 );
 
+function resolveDensityLegend(program, args) {
+  validateKeys(args, LEGEND_OPTIONS, "createGradientPlotLegend");
+  requireLegendOwner(program, args.owner);
+  if (args.position !== undefined && args.position !== "right") {
+    throw new Error('Gradient plot density legend currently requires position "right".');
+  }
+  if (args.title !== undefined && (typeof args.title !== "string" || args.title.length === 0)) {
+    throw new TypeError("Gradient plot density legend title must be a non-empty string.");
+  }
+  const ids = legendIds(args.owner);
+  const densityScale = `${args.owner}Density`;
+  const title = args.title ?? "Relative density";
+  return { ids, densityScale, title };
+}
+
+export function fulfillGradientPlotLegend(program, args) {
+  const { ids, densityScale } = resolveDensityLegend(program, args);
+  const occupied = program.semanticSpec.guides.legend?.color;
+  if (occupied !== undefined && occupied.scale !== densityScale) {
+    guideConflict("Gradient plot density legend uses a different scale or family");
+  }
+  const existing = Object.values(ids).filter(id => program.graphicSpec.objects[id] !== undefined);
+  if (existing.length === 0) return program.createGradientPlotLegend(args);
+  if (existing.length !== Object.keys(ids).length || occupied?.scale !== densityScale) {
+    guideConflict("Gradient plot density legend has incomplete ownership");
+  }
+  const { owner, ...explicit } = args;
+  assertGuideOptions(explicit, program.markConfigs[owner].gradientPlot.guides.legend, "Gradient plot density legend");
+  return program;
+}
+
 export const createGradientPlotLegend = action(
   {
     op: "createGradientPlotLegend",
     description: "Create the neutral density legend owned by one gradient plot."
   },
   function (args = {}) {
-    validateKeys(args, LEGEND_OPTIONS, "createGradientPlotLegend");
-    requireLegendOwner(this, args.owner);
-    if (args.position !== undefined && args.position !== "right") {
-      throw new Error('Gradient plot density legend currently requires position "right".');
-    }
-    if (args.title !== undefined && (typeof args.title !== "string" || args.title.length === 0)) {
-      throw new TypeError("Gradient plot density legend title must be a non-empty string.");
-    }
-    const ids = legendIds(args.owner);
-    const densityScale = `${args.owner}Density`;
-    const title = args.title ?? "Relative density";
+    const { ids, densityScale, title } = resolveDensityLegend(this, args);
     let next = this;
     for (const [property, value] of [
       [`scale[${densityScale}].type`, "sequential"],

package/src/actions/gradientPlots/edit.js

@@ -7,6 +7,7 @@ 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")
@@ -219,10 +227,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 +300,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

@@ -1,7 +1,10 @@
+import { applyFacadeGuides } from "../charts/shared.js";
+import { fulfillGradientPlotLegend } from "./components.js";
 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
@@ -246,26 +249,23 @@ 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;
     if (guides !== false) {
       const wantsStandard = guides.axes !== false || guides.grid !== false;
       if (wantsStandard) {
-        next = next.createGuides({
+        next = applyFacadeGuides(next, {
           axes: gradientAxesOptions(next.markConfigs[owner].gradientPlot),
           grid: guides.grid,
           legend: false
-        });
+        }, owner, guides);
       }
       if (guides.legend !== false) {
         const legend = isPlainObject(guides.legend) ? guides.legend : {};
-        next = next.createGradientPlotLegend({
-          owner,
-          title: legend.title ?? "Relative density",
-          position: legend.position ?? "right"
-        });
+        next = fulfillGradientPlotLegend(next, { owner, ...legend });
       }
     }
     return next._withContext({ currentMark: owner, currentData: layer.data });

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/guides/applicability.js

@@ -1,3 +1,4 @@
+import { isSourceOwnedText } from "../../grammar/text.js";
 import {
   BAR_ORIENTATIONS,
   resolveBarOrientation
@@ -8,6 +9,7 @@ import {
 } from "../../core/vocabulary.js";
 import { findSemanticScale } from "../../selectors/scales.js";
 import { findDataset } from "../../selectors/datasets.js";
+import { isOpacityLegendLayer } from "../../materialization/legends.js";
 import { findUpstreamTransform } from
   "../../materialization/dataProvenance.js";
 
@@ -19,8 +21,8 @@ function isHorizonLayer(program, layer) {
   ) !== undefined;
 }
 
-function hasEncoding(program, channel, { scaled = false, grid = false } = {}) {
-  return program.semanticSpec.layers.some(layer => {
+function hasEncoding(program, layers, channel, { scaled = false, grid = false } = {}) {
+  return layers.some(layer => {
     if (isHorizonLayer(program, layer) && channel !== "x") return false;
     const encoding = layer.encoding?.[channel];
     if (!scaled && !grid) return encoding !== undefined;
@@ -31,25 +33,26 @@ function hasEncoding(program, channel, { scaled = false, grid = false } = {}) {
   });
 }
 
-function positionalApplicability(program, channels) {
+function positionalApplicability(program, layers, channels) {
   return Object.freeze(Object.fromEntries(
     channels.map(channel => [
       channel,
       Object.freeze({
-        axis: hasEncoding(program, channel),
-        grid: hasEncoding(program, channel, { grid: true })
+        axis: hasEncoding(program, layers, channel),
+        grid: hasEncoding(program, layers, channel, { grid: true })
       })
     ])
   ));
 }
 
-export function hasInferableLegend(program) {
-  return program.semanticSpec.layers.some(layer =>
+export function hasInferableLegend(program, layers = program.semanticSpec.layers) {
+  return layers.some(layer =>
     !isHorizonLayer(program, layer) && (
-      (layer.mark?.type === "point" &&
-        layer.encoding?.opacity?.scale !== undefined) ||
+      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 ||
@@ -57,22 +60,27 @@ export function hasInferableLegend(program) {
             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)
     )
   );
 }
 
-export function resolveGuideApplicability(program) {
+export function resolveGuideApplicability(program, layers = program.semanticSpec.layers) {
   const cartesian = positionalApplicability(
     program,
+    layers,
     CARTESIAN_POSITION_CHANNELS
   );
-  const polar = positionalApplicability(program, POLAR_POSITION_CHANNELS);
-  const parallel = program.semanticSpec.layers.some(layer =>
+  const polar = positionalApplicability(program, layers, POLAR_POSITION_CHANNELS);
+  const parallel = layers.some(layer =>
     layer.encoding?.parallel?.dimensions?.length >= 2
   );
   return Object.freeze({
@@ -101,12 +109,13 @@ export function resolveGuideApplicability(program) {
         radial: polar.radius.grid
       })
     }),
-    legend: hasInferableLegend(program)
+    legend: hasInferableLegend(program, layers)
   });
 }
 
-export function resolveAutomaticGridOptions(program) {
-  const applicability = resolveGuideApplicability(program);
+export function resolveAutomaticGridOptions(program, layers = program.semanticSpec.layers) {
+  layers = layers.filter(layer => !isSourceOwnedText(layer));
+  const applicability = resolveGuideApplicability(program, layers);
   const directions = applicability.grid.directions;
   if (applicability.grid.polar && !applicability.grid.cartesian) {
     return Object.freeze({
@@ -118,10 +127,10 @@ export function resolveAutomaticGridOptions(program) {
     return Object.freeze({ horizontal: false, vertical: {} });
   }
 
-  const barOrientations = program.semanticSpec.layers
+  const barOrientations = layers
     .map(resolveBarOrientation)
     .filter(Boolean);
-  const positionedLayers = program.semanticSpec.layers.filter(
+  const positionedLayers = layers.filter(
     layer => layer.encoding?.x !== undefined && layer.encoding?.y !== undefined
   );
   const horizontalQuantitative = positionedLayers.length > 0 &&

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

@@ -1,3 +1,4 @@
+import { isSourceOwnedText } from "../../../grammar/text.js";
 import { action } from "../../../core/action.js";
 import { isPlainObject } from "../../../core/immutable.js";
 import { validateUserId } from "../../../core/identifiers.js";
@@ -19,7 +20,7 @@ function validateAxisOption(value, channel) {
   }
 }
 
-function validateArgs(args) {
+export function validateAxesArgs(args) {
   validateOptionObject(args, TOP_OPTIONS, "createAxes");
   validateAxisOption(args.x, "x");
   validateAxisOption(args.y, "y");
@@ -189,9 +190,9 @@ const createAxes = action(
     description: "Read a semantic coordinate and create its Cartesian axes."
   },
   function (args = {}) {
-    const coordinateDescriptor = validateArgs(args);
+    const coordinateDescriptor = validateAxesArgs(args);
     const { cartesianLayers, polarLayers, parallelLayers } = inspectChannels(
-      this.semanticSpec.layers
+      this.semanticSpec.layers.filter(layer => !isSourceOwnedText(layer))
     );
     const requestedCoordinateType = coordinateDescriptor.id === undefined
       ? undefined