ggaction 0.0.18 → 0.0.19

package/src/actions/data/shared.js

@@ -35,9 +35,11 @@ export function requireDerivedDataset(program, id, type) {
   return { id: validatedId, dataset, source, transform: dataset.transform[0] };
 }
 
-export function derivedMaterializer(op, description, type, derive, resolve) {
+export function derivedMaterializer(op, description, type, derive, resolve, { before, after } = {}) {
   return action({ op, description }, function (args = {}) {
     validateKeys(args, MATERIALIZE_OPTIONS, op);
+    const existing = before?.(this, args);
+    if (existing !== undefined) return existing;
     const { id, source, transform } = requireDerivedDataset(
       this,
       args.id,
@@ -51,6 +53,7 @@ export function derivedMaterializer(op, description, type, derive, resolve) {
     const values = Array.isArray(result) ? result : result.values;
     const schema = deriveTransformSchema(source.schema, transform, values, {
       sourceId: source.id,
+      sourceTransform: source.transform?.[0],
       ownerId: id
     });
     validateRowsAgainstSchema(values, schema, `Derived dataset "${id}"`);
@@ -75,7 +78,7 @@ export function derivedMaterializer(op, description, type, derive, resolve) {
         report
       );
     }
-    return next;
+    return after === undefined ? next : after(next, { id, source, transform, result });
   });
 }
 

package/src/actions/distributions/revision.js

@@ -1,3 +1,4 @@
+import { cartesianAxisOwners, axisTargetArgs } from "../../selectors/axes.js";
 import { DEFAULT_TICK_COUNT } from "../guides/tickValues.js";
 import { findLayer } from "../../selectors/layers.js";
 import { findSemanticScale } from "../../selectors/scales.js";
@@ -296,39 +297,44 @@ export function clearCartesianPositions(program, id) {
   return next;
 }
 
-function rebindAxis(program, channel, {
+function rebindAxis(program, channel, options) {
+  return cartesianAxisOwners(program).filter(owner => owner.channel === channel)
+    .reduce((next, owner) => rebindAxisOwner(next, channel, owner.id, options), program);
+}
+
+function rebindAxisOwner(program, channel, axisId, {
   previousScale,
   nextScale,
   previousTitle,
   nextTitle
 }) {
-  const semantic = program.semanticSpec.guides.axis?.[channel];
+  const semantic = program.semanticSpec.guides.axis?.[axisId];
   if (semantic?.scale !== previousScale) return program;
   let next = program.editSemantic({
-    property: `guide.axis.${channel}.scale`,
+    property: `guide.axis.${axisId}.scale`,
     value: nextScale
   });
   if (semantic.title === previousTitle) {
     next = next.editSemantic({
-      property: `guide.axis.${channel}.title`,
+      property: `guide.axis.${axisId}.title`,
       value: nextTitle
     });
   }
   const scale = next.resolvedScales[nextScale];
   const ticks = normalizeTickConfig(
-    next.guideConfigs.axis?.[channel]?.ticks,
+    next.guideConfigs.axis?.[axisId]?.ticks,
     scale
   );
   if (ticks !== undefined) {
-    next = next._withGuideConfig(channel, "ticks", {
+    next = next._withGuideConfig(axisId, "ticks", {
       ...ticks,
       scale: nextScale
     });
   }
-  const labels = next.guideConfigs.axis?.[channel]?.labels;
+  const labels = next.guideConfigs.axis?.[axisId]?.labels;
   if (labels !== undefined) {
-    const tickConfig = next.guideConfigs.axis[channel].ticks;
-    next = next._withGuideConfig(channel, "labels", {
+    const tickConfig = next.guideConfigs.axis[axisId].ticks;
+    next = next._withGuideConfig(axisId, "labels", {
       ...labels,
       scale: nextScale,
       mode: tickConfig.mode,
@@ -338,30 +344,30 @@ function rebindAxis(program, channel, {
         : { count: tickConfig.count })
     });
     if (tickConfig.mode === "values") {
-      const config = next.guideConfigs.axis[channel].labels;
+      const config = next.guideConfigs.axis[axisId].labels;
       if (Object.hasOwn(config, "count")) {
         const { count: _count, ...withoutCount } = config;
-        next = next._withGuideConfig(channel, "labels", withoutCount);
+        next = next._withGuideConfig(axisId, "labels", withoutCount);
       }
     } else {
-      const config = next.guideConfigs.axis[channel].labels;
+      const config = next.guideConfigs.axis[axisId].labels;
       if (Object.hasOwn(config, "values")) {
         const { values: _values, ...withoutValues } = config;
-        next = next._withGuideConfig(channel, "labels", withoutValues);
+        next = next._withGuideConfig(axisId, "labels", withoutValues);
       }
     }
   }
-  const title = next.guideConfigs.axis?.[channel]?.title;
+  const title = next.guideConfigs.axis?.[axisId]?.title;
   if (title !== undefined) {
-    next = next._withGuideConfig(channel, "title", {
+    next = next._withGuideConfig(axisId, "title", {
       ...title,
       scale: nextScale
     });
   }
   const methods = axisMethods(channel);
-  if (ticks !== undefined) next = next[methods.ticks]();
-  if (labels !== undefined) next = next[methods.labels]();
-  if (title !== undefined) next = next[methods.title]();
+  if (ticks !== undefined) next = next[methods.ticks](axisId === channel ? undefined : axisTargetArgs(axisId, channel));
+  if (labels !== undefined) next = next[methods.labels](axisId === channel ? undefined : axisTargetArgs(axisId, channel));
+  if (title !== undefined) next = next[methods.title](axisId === channel ? undefined : axisTargetArgs(axisId, channel));
   return next;
 }
 

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";
 
@@ -41,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"])
 });
@@ -144,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 })
       });
     }

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/facets/actions.js

@@ -60,7 +60,7 @@ const HEADER_STYLE_OPTIONS = Object.freeze([
   "fontSize", "fontFamily", "fontWeight", "color", "offset", "align"
 ]);
 
-function normalizeGuides(guides) {
+function normalizeGuides(guides, allowStored = false) {
   if (guides === undefined) return { axes: "each", legend: false };
   validateOptionObject(guides, GUIDE_OPTIONS, "facet.guides");
   const axes = guides.axes ?? "each";
@@ -68,8 +68,11 @@ function normalizeGuides(guides) {
     throw new Error('facet guides.axes must be "each" or "outer".');
   }
   const legend = guides.legend ?? false;
-  if (legend !== false && legend !== "shared") {
-    throw new Error('facet guides.legend must be false or "shared".');
+  if (legend !== false && legend !== "shared" && !isPlainObject(legend)) {
+    throw new Error('facet guides.legend must be false, "shared", or legend options.');
+  }
+  if (!allowStored && isPlainObject(legend) && Object.hasOwn(legend, "type")) {
+    throw new Error("Facet legend options do not accept internal type tags.");
   }
   return { axes, legend };
 }
@@ -617,7 +620,8 @@ export const editFacetGuides = /* @__PURE__ */ action(
       emptyMessage: "editFacetGuides requires at least one guide policy."
     });
     const current = this.compositionSpec.facet;
-    const guides = normalizeGuides({ ...current.guides, ...args });
+    if (Object.hasOwn(args, "legend")) normalizeGuides({ legend: args.legend });
+    const guides = normalizeGuides({ ...current.guides, ...args }, true);
     const family = resolveFacetFamily(this.semanticSpec).family;
     if (family !== "cartesian" && guides.axes === "outer") {
       throw new Error("Polar and Parallel facets do not support outer axes.");
@@ -688,6 +692,8 @@ export const editFacetSource = /* @__PURE__ */ closedAction(
     const current = this.compositionSpec;
     const facetConfig = this.materializationConfigs.facets?.[current.id];
     const base = adoptUnitState(args.program, this);
+    const authored = isPlainObject(current.facet.guides.legend);
+    const guides = authored ? { ...current.facet.guides, legend: false } : current.facet.guides;
     let revised;
     const scales = usedFacetScalePolicies(base, current.facet.scales);
     if (current.facet.grid !== undefined) {
@@ -702,7 +708,7 @@ export const editFacetSource = /* @__PURE__ */ closedAction(
         align: current.align,
         padding: current.padding,
         scales,
-        guides: current.facet.guides
+        guides
       });
     } else if (current.facet.repeat !== undefined) {
       revised = base.repeatCharts({
@@ -714,7 +720,7 @@ export const editFacetSource = /* @__PURE__ */ closedAction(
         align: current.align,
         padding: current.padding,
         scales,
-        guides: current.facet.guides
+        guides
       });
     } else {
       revised = base.facet({
@@ -728,9 +734,14 @@ export const editFacetSource = /* @__PURE__ */ closedAction(
         align: current.align,
         padding: current.padding,
         scales,
-        guides: current.facet.guides
+        guides
       });
     }
+    if (authored) {
+      const spec = revised.compositionSpec;
+      revised = revised._withCompositionState({ children: revised.children,
+        compositionSpec: { ...spec, facet: { ...spec.facet, guides: current.facet.guides } } });
+    }
     if (facetConfig !== undefined) {
       revised = revised
         ._withMaterializationConfig(["facets", current.id], facetConfig)

package/src/actions/facets/guides.js

@@ -1,3 +1,4 @@
+import { synchronizeFacetColorSizeMeaning } from "../primitives/semanticAction.js";
 import { closedAction } from "../../core/action.js";
 
 import { applyFacetGuideComposition } from
@@ -10,6 +11,6 @@ export const composeFacetGuides = /* @__PURE__ */ closedAction(
     scope: "composition"
   }, ["layout", "plot"],
   function ({ layout, plot } = {}) {
-    return applyFacetGuideComposition(this, { layout, plot });
+    return applyFacetGuideComposition(this, { layout, plot, synchronizeColorSizeMeaning: synchronizeFacetColorSizeMeaning });
   }
 );

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

@@ -1,3 +1,4 @@
+import { withGuideLayoutTransaction } from "../../../materialization/guides/layout.js";
 import { isSourceOwnedText } from "../../../grammar/text.js";
 import { action } from "../../../core/action.js";
 import { isPlainObject } from "../../../core/immutable.js";
@@ -15,6 +16,13 @@ const COORDINATE_API_TYPES = new Set([
 ]);
 
 function validateAxisOption(value, channel) {
+  if (["x", "y"].includes(channel) && Array.isArray(value)) {
+    if (value.length === 0 || value.some(entry => !isPlainObject(entry) || !Object.hasOwn(entry, "id"))) {
+      throw new TypeError(`createAxes ${channel} arrays require nonempty named axis descriptors.`);
+    }
+    for (const entry of value) validateUserId(entry.id, "Axis id");
+    return;
+  }
   if (value !== undefined && value !== false && !isPlainObject(value)) {
     throw new TypeError(`createAxes ${channel} must be false or a plain object.`);
   }
@@ -287,23 +295,34 @@ const createAxes = /* @__PURE__ */ action(
       coordinateDescriptor,
       cartesianLayers
     );
-    const x = resolveAxisArgs(coordinate.layers, "x", args.x);
-    const y = resolveAxisArgs(coordinate.layers, "y", args.y);
+    const resolve = (channel, value) => Array.isArray(value)
+      ? value.map(entry => resolveAxisArgs(coordinate.layers, channel, entry))
+      : resolveAxisArgs(coordinate.layers, channel, value);
+    const x = resolve("x", args.x);
+    const y = resolve("y", args.y);
 
     if (x === undefined && y === undefined) {
       throw new Error("createAxes requires at least one selected axis.");
     }
 
-    let program = this;
-
-    if (x !== undefined) {
-      program = program.createXAxis({ ...x, coordinate: coordinate.id });
-    }
-    if (y !== undefined) {
-      program = program.createYAxis({ ...y, coordinate: coordinate.id });
+    const apply = source => {
+      let program = source;
+      for (const [channel, option] of [["x", x], ["y", y]]) {
+        if (option === undefined) continue;
+        for (const entry of Array.isArray(option) ? option : [option]) {
+          program = program[`create${channel.toUpperCase()}Axis`]({ ...entry, coordinate: coordinate.id });
+        }
+      }
+      return program;
+    };
+    if (Array.isArray(x) || Array.isArray(y)) {
+      const ids = [...(Array.isArray(x) ? x : x === undefined ? [] : [x]),
+        ...(Array.isArray(y) ? y : y === undefined ? [] : [y])].map((entry, index) => entry.id ?? (index === 0 ? "x" : "y"));
+      if (new Set(ids).size !== ids.length) throw new Error("createAxes requires unique axis ids across its descriptors.");
+      withGuideLayoutTransaction(this, apply);
+      return withGuideLayoutTransaction(this, apply);
     }
-
-    return program;
+    return apply(this);
   }
 );
 

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

@@ -1,21 +1,27 @@
+import { AXIS_RESOURCE_CHANNELS } from "../../../core/vocabulary.js";
+import { cartesianAxisOwners, axisTargetArgs, assertCartesianAxisSideAvailable } from "../../../selectors/axes.js";
+import { axisGraphicIds } from "../../../materialization/guides/resources.js";
+import { defaultAxisPosition, validateAxisPosition } from "./policy.js";
 import { isSourceOwnedText } from "../../../grammar/text.js";
 import { withGuideLayoutValidation } from "../../../materialization/guides/layout.js";
 import { action } from "../../../core/action.js";
 import { isPlainObject } from "../../../core/immutable.js";
 import { validateUserId } from "../../../core/identifiers.js";
-import { validateKeys } from "../../../core/validation.js";
+import { validateKeys, validateNonNegativeFinite } from "../../../core/validation.js";
 import { hasCoordinate } from "../../../selectors/index.js";
 import { validateEnabledAxisComponents } from "./components.js";
 import { requireSemanticScale } from "../../../selectors/scales.js";
 import { requireCoordinate } from "../../../selectors/coordinates.js";
 
 const TOP_OPTIONS = Object.freeze([
+  "id",
   "scale",
   "coordinate",
   "position",
   "line",
   "ticksAndLabels",
-  "title"
+  "title",
+  "offset"
 ]);
 const LINE_OPTIONS = Object.freeze(["color", "lineWidth"]);
 const TICK_GROUP_OPTIONS = Object.freeze([
@@ -32,7 +38,8 @@ const TITLE_OPTIONS = Object.freeze([
   "color",
   "fontSize",
   "fontFamily",
-  "fontWeight"
+  "fontWeight",
+  "alongOffset", "align", "baseline"
 ]);
 
 function validateNested(value, supported, label) {
@@ -45,6 +52,7 @@ function validateNested(value, supported, label) {
 
 export function validateAxisArgs(args, operation) {
   validateKeys(args, TOP_OPTIONS, operation);
+  if (Object.hasOwn(args, "offset")) validateNonNegativeFinite(args.offset, "Axis frame offset");
 
   validateEnabledAxisComponents(args, operation);
   if (Object.hasOwn(args, "line") && args.line !== false) {
@@ -84,10 +92,52 @@ function makeCreateAxis(channel) {
     },
     withGuideLayoutValidation(function (args = {}) {
       validateAxisArgs(args, operation.create);
-      const shared = {};
+      const axisId = validateUserId(args.id ?? channel, "Axis id");
+      if (AXIS_RESOURCE_CHANNELS.includes(axisId) && axisId !== channel) {
+        throw new Error(`Axis id "${axisId}" is reserved for another axis channel.`);
+      }
+      const named = axisId !== channel;
+      let source = this;
+      if (named) {
+        if (cartesianAxisOwners(this).some(owner => owner.id === axisId) ||
+            axisGraphicIds(channel, axisId).some(id => this.graphicSpec.objects[id] !== undefined)) {
+          throw new Error(`Axis "${axisId}" requires a missing resource and missing concrete components.`);
+        }
+        const layers = this.semanticSpec.layers.filter(layer => !isSourceOwnedText(layer) &&
+          layer.encoding?.[channel]?.scale !== undefined &&
+          (args.coordinate === undefined || layer.coordinate === args.coordinate) &&
+          (args.scale === undefined || layer.encoding[channel].scale === args.scale));
+        const scales = [...new Set(layers.map(layer => layer.encoding[channel].scale))];
+        if (args.scale === undefined && scales.length !== 1) throw new Error("Named axes require an explicit scale when the channel binding is ambiguous.");
+        const scale = args.scale ?? scales[0];
+        const coordinates = [...new Set(layers.map(layer => layer.coordinate))];
+        if (args.coordinate === undefined && coordinates.length !== 1) throw new Error("Named axes require an explicit coordinate when the binding is ambiguous.");
+        const coordinate = args.coordinate ?? coordinates[0];
+        if (requireCoordinate(this, coordinate).type !== "cartesian") throw new Error("Named Cartesian axes require a Cartesian coordinate.");
+        const position = validateAxisPosition(channel, args.position ?? defaultAxisPosition(channel));
+        assertCartesianAxisSideAvailable(this, { id: axisId, channel, coordinate, position });
+        args = { ...args, scale, coordinate, position };
+        source = source.editSemantic({ property: `guide.axis.${axisId}.channel`, value: channel })
+          .editSemantic({ property: `guide.axis.${axisId}.position`, value: position })
+          .editSemantic({ property: `guide.axis.${axisId}.scale`, value: scale })
+          .editSemantic({ property: `guide.axis.${axisId}.coordinate`, value: coordinate });
+      } else if (cartesianAxisOwners(this).some(owner => owner.named)) {
+        const scale = args.scale ?? channel;
+        const coordinates = [...new Set(this.semanticSpec.layers.filter(layer =>
+          layer.encoding?.[channel]?.scale === scale).map(layer => layer.coordinate))];
+        const coordinate = args.coordinate ?? (coordinates.length === 1 ? coordinates[0] : undefined);
+        assertCartesianAxisSideAvailable(this, { id: axisId, channel, coordinate,
+          position: validateAxisPosition(channel, args.position ?? defaultAxisPosition(channel)) });
+        if (!cartesianAxisOwners(this).some(owner => owner.id === channel)) {
+          source = source.editSemantic({ property: `guide.axis.${axisId}.scale`, value: scale });
+          if (coordinate !== undefined) source = source.editSemantic({ property: `guide.axis.${axisId}.coordinate`, value: coordinate });
+        }
+      }
+      const shared = axisTargetArgs(axisId, channel);
       if (Object.hasOwn(args, "scale")) shared.scale = args.scale;
       if (Object.hasOwn(args, "position")) shared.position = args.position;
-      let next = this;
+      let next = Object.hasOwn(args, "offset")
+        ? source._withGuideConfig(axisId, "frame", { offset: args.offset }) : source;
 
       if (Object.hasOwn(args, "coordinate")) {
         const coordinate = validateUserId(args.coordinate, "Coordinate id");
@@ -116,11 +166,11 @@ function makeCreateAxis(channel) {
         }
 
         next = next.editSemantic({
-          property: `guide.axis.${channel}.coordinate`,
+          property: `guide.axis.${axisId}.coordinate`,
           value: coordinate
         });
-        if (standalone) next = next._withGuideConfig(channel, "binding", { standalone: true })
-          .editSemantic({ property: `guide.axis.${channel}.scale`, value: scale })
+        if (standalone) next = next._withGuideConfig(axisId, "binding", { standalone: true })
+          .editSemantic({ property: `guide.axis.${axisId}.scale`, value: scale })
           .rematerializeScale({ id: scale, guides: false, marks: false });
       }
 

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

@@ -2,8 +2,8 @@ import { axisGraphicIds } from "../../../materialization/guides/resources.js";
 
 export const AXIS_COMPONENTS = Object.freeze(["line", "ticks", "labels", "title"]);
 
-export function axisComponentId(channel, component) {
-  return axisGraphicIds(channel)[AXIS_COMPONENTS.indexOf(component)];
+export function axisComponentId(channel, component, axisId = channel) {
+  return axisGraphicIds(channel, axisId)[AXIS_COMPONENTS.indexOf(component)];
 }
 
 export function axisComponentDisabled(args, component) {
@@ -17,27 +17,27 @@ export function validateEnabledAxisComponents(args, operation) {
   }
 }
 
-export function hasAxisComponent(program, channel, component) {
-  return program.graphicSpec.objects[axisComponentId(channel, component)] !== undefined ||
-    program.guideConfigs.axis?.[channel]?.[component] !== undefined ||
+export function hasAxisComponent(program, channel, component, axisId = channel) {
+  return program.graphicSpec.objects[axisComponentId(channel, component, axisId)] !== undefined ||
+    program.guideConfigs.axis?.[axisId]?.[component] !== undefined ||
     (component === "title" &&
-      program.semanticSpec.guides.axis?.[channel]?.title !== undefined);
+      program.semanticSpec.guides.axis?.[axisId]?.title !== undefined);
 }
 
-export function assertRemovableAxisComponent(program, channel, component, operation) {
-  if (!hasAxisComponent(program, channel, component)) {
+export function assertRemovableAxisComponent(program, channel, component, operation, axisId = channel) {
+  if (!hasAxisComponent(program, channel, component, axisId)) {
     throw new Error(`${operation}.${component} requires an existing ${channel}-axis ${component}.`);
   }
 }
 
-export function removeAxisComponent(program, channel, component) {
-  const id = axisComponentId(channel, component);
+export function removeAxisComponent(program, channel, component, axisId = channel) {
+  const id = axisComponentId(channel, component, axisId);
   let next = program;
-  if (component === "title" && next.semanticSpec.guides.axis?.[channel]?.title !== undefined) {
-    next = next.editSemantic({ property: `guide.axis.${channel}.title`, remove: true });
+  if (component === "title" && next.semanticSpec.guides.axis?.[axisId]?.title !== undefined) {
+    next = next.editSemantic({ property: `guide.axis.${axisId}.title`, remove: true });
   }
   if (next.graphicSpec.objects[id] !== undefined) {
     next = next.editGraphics({ target: id, remove: true });
   }
-  return next._withoutMaterializationConfig(["guides", "axis", channel, component]);
+  return next._withoutMaterializationConfig(["guides", "axis", axisId, component]);
 }