ggaction 0.0.3 → 0.0.5

package/src/actions/guides/guides.js

@@ -5,6 +5,9 @@ import {
   resolveAutomaticGridOptions,
   resolveGuideApplicability
 } from "./applicability.js";
+import { findDataset } from "../../selectors/datasets.js";
+import { findUpstreamTransform } from
+  "../../materialization/dataProvenance.js";
 
 const OPTIONS = Object.freeze(["axes", "grid", "legend"]);
 
@@ -21,16 +24,51 @@ function validateOptions(args) {
   validateGuideOption(args.legend, "createGuides legend");
 }
 
-function inferAxesOptions(program) {
+function inferAxesOptions(program, applicability) {
   const horizontalInterval = program.semanticSpec.layers.some(layer =>
     layer.mark?.type === "rule" &&
     layer.encoding?.x?.fieldType === "quantitative" &&
     layer.encoding?.x2?.fieldType === "quantitative" &&
     ["nominal", "ordinal", "temporal"].includes(layer.encoding?.y?.fieldType)
   );
-  return horizontalInterval
+  const inferred = horizontalInterval
     ? { x: { ticksAndLabels: { count: 7 } } }
     : {};
+  const directions = applicability.axes.directions;
+  const hasStoredY = program.semanticSpec.layers.some(
+    layer => layer.encoding?.y !== undefined
+  );
+  if (!directions.y && hasStoredY) inferred.y = false;
+  const horizonLayers = program.semanticSpec.layers.filter(layer =>
+    findUpstreamTransform(
+      program,
+      findDataset(program, layer.data),
+      "horizon"
+    ) !== undefined
+  );
+  if (horizonLayers.length === 1 && directions.x && !directions.y) {
+    const scaleId = horizonLayers[0].encoding?.x?.scale;
+    const domain = program.resolvedScales?.[scaleId]?.domain;
+    if (
+      Array.isArray(domain) &&
+      domain.length === 2 &&
+      domain.every(Number.isFinite) &&
+      domain[0] !== domain[1]
+    ) {
+      const low = Math.min(...domain);
+      const high = Math.max(...domain);
+      inferred.x = {
+        ...(inferred.x ?? {}),
+        ticksAndLabels: {
+          values: Array.from(
+            { length: 6 },
+            (_, index) => low + (high - low) * index / 5
+          )
+        }
+      };
+    }
+  }
+  return inferred;
 }
 
 function selectOption(explicit, applicable) {
@@ -39,6 +77,17 @@ function selectOption(explicit, applicable) {
   return applicable ? {} : undefined;
 }
 
+function mergeInferredOptions(inferred, explicit) {
+  if (!isPlainObject(inferred) || !isPlainObject(explicit)) return explicit;
+  const merged = { ...inferred };
+  for (const [key, value] of Object.entries(explicit)) {
+    merged[key] = isPlainObject(value) && isPlainObject(inferred[key])
+      ? mergeInferredOptions(inferred[key], value)
+      : value;
+  }
+  return merged;
+}
+
 const createGuides = action(
   {
     op: "createGuides",
@@ -47,10 +96,16 @@ const createGuides = action(
   function (args = {}) {
     validateOptions(args);
     const applicability = resolveGuideApplicability(this);
-    const hasAxes = applicability.axes.cartesian || applicability.axes.polar;
+    const hasAxes = applicability.axes.cartesian || applicability.axes.polar ||
+      applicability.axes.parallel;
+    const inferredAxes = applicability.axes.cartesian
+      ? inferAxesOptions(this, applicability)
+      : {};
     const axes = args.axes === undefined && applicability.axes.cartesian
-      ? inferAxesOptions(this)
-      : selectOption(args.axes, hasAxes);
+      ? inferredAxes
+      : args.axes !== undefined && args.axes !== false && hasAxes
+        ? mergeInferredOptions(inferredAxes, args.axes)
+        : selectOption(args.axes, hasAxes);
     const grid = args.grid === undefined &&
         (applicability.grid.cartesian || applicability.grid.polar)
       ? resolveAutomaticGridOptions(this)

package/src/actions/guides/legends/categorical/actions.js

@@ -5,6 +5,9 @@ import { normalizeOptions } from "./options.js";
 import { findLayer } from "../../../../selectors/layers.js";
 import { findSemanticScale } from "../../../../selectors/scales.js";
 import { isSizeLegendPoint } from "../size.js";
+import { isStrokeWidthLegendLayer } from "../strokeWidth.js";
+import { legendResourcePolicies } from
+  "../../../../materialization/guides/resources.js";
 import {
   resolveCurrentDefinition,
   resolveDefinition,
@@ -80,17 +83,13 @@ export const rematerializeLegend = action(
       ).some(highlight => highlight.target === config.target);
       if (hasHighlight) next = next.rematerializeLegendHighlights();
     }
-    if (this.guideConfigs.legend?.size !== undefined) {
-      next = next.rematerializeSizeLegend();
-    }
-    if (this.guideConfigs.legend?.gradient !== undefined) {
-      next = next.rematerializeGradientLegend();
-    }
-    if (this.guideConfigs.legend?.interval !== undefined) {
-      next = next.rematerializeIntervalLegend();
-    }
-    if (this.guideConfigs.legend?.opacity !== undefined) {
-      next = next.rematerializeOpacityLegend();
+    for (const policy of legendResourcePolicies()) {
+      if (
+        policy.rematerializeOp !== undefined &&
+        this.guideConfigs.legend?.[policy.kind] !== undefined
+      ) {
+        next = next[policy.rematerializeOp]();
+      }
     }
     return next;
   }
@@ -177,6 +176,8 @@ export const createLegend = action(
       throw new TypeError("createLegend channels must be an array.");
     }
     const explicitSize = channels?.length === 1 && channels[0] === "size";
+    const explicitStrokeWidth = channels?.length === 1 &&
+      channels[0] === "strokeWidth";
     const requestedSizeLayer = args.target === undefined
       ? undefined
       : findLayer(this, args.target);
@@ -216,6 +217,42 @@ export const createLegend = action(
         ...(count === undefined ? {} : { count })
       });
     }
+    const strokeWidthCandidates = this.semanticSpec.layers.filter(
+      isStrokeWidthLegendLayer
+    );
+    const requestedStrokeWidthLayer = args.target === undefined
+      ? undefined
+      : findLayer(this, args.target);
+    const hasOtherStrokeWidthLegendCandidate = this.semanticSpec.layers.some(
+      layer => ["color", "shape", "strokeDash", "size", "opacity"].some(
+        channel => layer.encoding?.[channel]?.scale !== undefined
+      )
+    );
+    const inferredStrokeWidth = channels === undefined && (
+      (args.target !== undefined &&
+        isStrokeWidthLegendLayer(requestedStrokeWidthLayer) &&
+        !hasNonSizeLegendEncoding(requestedStrokeWidthLayer)) ||
+      (args.target === undefined && strokeWidthCandidates.length === 1 &&
+        !hasOtherStrokeWidthLegendCandidate)
+    );
+    if (explicitStrokeWidth || inferredStrokeWidth) {
+      const { target, count, position, channels: _channels, ...unsupported } = args;
+      const unsupportedKeys = Object.keys(unsupported);
+      if (unsupportedKeys.length > 0) {
+        throw new Error(
+          `Standalone stroke-width legend does not support option "${unsupportedKeys[0]}".`
+        );
+      }
+      if (position !== undefined && position !== "right") {
+        throw new Error(
+          'Standalone stroke-width legends currently require position "right".'
+        );
+      }
+      return this.createStrokeWidthLegend({
+        ...(target === undefined ? {} : { target }),
+        ...(count === undefined ? {} : { count })
+      });
+    }
     const opacityCandidates = this.semanticSpec.layers.filter(layer =>
       layer.mark?.type === "point" && layer.encoding?.opacity?.scale !== undefined
     );

package/src/actions/guides/legends/categorical/layout.js

@@ -1,6 +1,6 @@
 import { isPlainObject } from "../../../../core/immutable.js";
 import { noOptions } from "../../../../core/validation.js";
-import { mapOrdinalValues } from "../../../../grammar/scales.js";
+import { mapOrdinalValues } from "../../../../grammar/scales/index.js";
 import { resolveGraphicBounds } from "../../../../layout/canvas.js";
 import { unionConcreteGraphicBounds } from "../../../../grammar/schemas/graphicBounds.js";
 import { DEFAULT_COLORS } from "../../../../theme/defaults.js";
@@ -382,7 +382,9 @@ export function resolveLayout(program, config) {
   const count = config.domain.length;
   const width = symbolWidth(config);
   if (config.position === "right") {
-    const symbolX = Array(count).fill(bounds.x + bounds.width + 30);
+    const symbolX = Array(count).fill(
+      bounds.x + bounds.width + config.offset
+    );
     const itemY = Array.from(
       { length: count },
       (_, index) => bounds.y + 52 + index * config.itemGap

package/src/actions/guides/legends/continuous/interval.js

@@ -4,7 +4,7 @@ import {
   validateKeys,
   validateOptionObject
 } from "../../../../core/validation.js";
-import { formatDiscretizedIntervals } from "../../../../grammar/scales.js";
+import { formatDiscretizedIntervals } from "../../../../grammar/scales/index.js";
 import { DEFAULT_COLORS, DEFAULT_FONT_FAMILY } from
   "../../../../theme/defaults.js";
 import {

package/src/actions/guides/legends/continuous/opacity.js

@@ -1,7 +1,7 @@
 import { action } from "../../../../core/action.js";
 import { isPlainObject } from "../../../../core/immutable.js";
 import { validateKeys } from "../../../../core/validation.js";
-import { mapLinearValues } from "../../../../grammar/scales.js";
+import { mapLinearValues } from "../../../../grammar/scales/index.js";
 import { DEFAULT_COLORS } from "../../../../theme/defaults.js";
 import {
   assertLegendInsideCanvas,

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

@@ -1,5 +1,4 @@
 import { action } from "../../../core/action.js";
-import { validateUserId } from "../../../core/identifiers.js";
 import { validateOptionObject } from "../../../core/validation.js";
 import { normalizeOptions } from "./categorical/options.js";
 import { symbolGraphic } from "./categorical/layout.js";
@@ -12,6 +11,7 @@ import { normalizeIntervalLegend } from "./continuous/interval.js";
 import { findLayer } from "../../../selectors/layers.js";
 import { resolveLegendGraphicPlacement } from
   "../../../materialization/graphicHierarchy.js";
+import { resolveLegendTarget } from "./target.js";
 
 const OPTIONS = Object.freeze([
   "target", "position", "align", "direction", "columns", "offset",
@@ -31,24 +31,6 @@ function mergeBorder(previous, patch) {
   return previous === false ? patch : { ...previous, ...patch };
 }
 
-function resolveTarget(program, requested) {
-  const configs = program.guideConfigs.legend ?? {};
-  const targets = [...new Set(Object.values(configs)
-    .map(config => config?.target)
-    .filter(Boolean))];
-  if (requested !== undefined) {
-    const target = validateUserId(requested, "Legend target id");
-    if (!targets.includes(target)) {
-      throw new Error(`Unknown legend target "${target}".`);
-    }
-    return target;
-  }
-  if (targets.length !== 1) {
-    throw new Error("editLegend requires target when the legend is ambiguous.");
-  }
-  return targets[0];
-}
-
 function reconcileGraphic(program, id, shouldExist, definition) {
   const exists = program.graphicSpec.objects[id] !== undefined;
   if (exists && !shouldExist) return program.editGraphics({ target: id, remove: true });
@@ -285,7 +267,7 @@ export const editLegend = action(
     )) {
       throw new TypeError('editLegend title must be a non-empty string, "auto", or false.');
     }
-    const target = resolveTarget(this, args.target);
+    const target = resolveLegendTarget(this, args.target, "editLegend");
     const configs = this.guideConfigs.legend ?? {};
     const categoricalKind = ["series", "color"].find(
       kind => configs[kind]?.target === target
@@ -302,6 +284,11 @@ export const editLegend = action(
     if (configs.interval?.target === target) {
       return editInterval(this, configs.interval, args);
     }
+    if (configs.strokeWidth?.target === target) {
+      throw new Error(
+        "editLegend does not yet support stroke-width legends; edit the owning scale instead."
+      );
+    }
     const continuousKind = ["gradient", "opacity"].find(
       kind => configs[kind]?.target === target
     );

package/src/actions/guides/legends/index.js

@@ -1,6 +1,7 @@
 import { registerCategoricalLegendActions } from "./categorical/index.js";
 import { registerContinuousLegendActions } from "./continuous/index.js";
 import { registerSizeLegendActions } from "./size.js";
+import { registerStrokeWidthLegendActions } from "./strokeWidth.js";
 import { registerFocusedLegendActions } from "./focused.js";
 import { removeLegend } from "./remove.js";
 
@@ -8,6 +9,7 @@ export function registerLegendActions(ProgramClass) {
   registerCategoricalLegendActions(ProgramClass);
   registerContinuousLegendActions(ProgramClass);
   registerSizeLegendActions(ProgramClass);
+  registerStrokeWidthLegendActions(ProgramClass);
   registerFocusedLegendActions(ProgramClass);
   ProgramClass.prototype.removeLegend = removeLegend;
 }

package/src/actions/guides/legends/remove.js

@@ -1,47 +1,22 @@
 import { action } from "../../../core/action.js";
-import { validateUserId } from "../../../core/identifiers.js";
 import { validateKeys } from "../../../core/validation.js";
-import { legendGraphicIds } from
+import { legendGraphicIds, legendResourcePolicy } from
   "../../../materialization/guides/resources.js";
+import { resolveLegendTarget } from "./target.js";
 
 const OPTIONS = Object.freeze(["target"]);
 
-function resolveTarget(program, requested) {
-  const targets = [...new Set(Object.values(program.guideConfigs.legend ?? {})
-    .map(config => config?.target)
-    .filter(Boolean))];
-  if (requested !== undefined) {
-    const target = validateUserId(requested, "Legend target id");
-    if (!targets.includes(target)) {
-      throw new Error(`Unknown legend target "${target}".`);
-    }
-    return target;
-  }
-  if (targets.length === 0) throw new Error("removeLegend requires an existing legend.");
-  if (targets.length > 1) {
-    throw new Error("removeLegend requires target when the legend is ambiguous.");
-  }
-  return targets[0];
-}
-
-const SEMANTIC_KIND = Object.freeze({
-  series: "series",
-  color: "color",
-  size: "size",
-  gradient: "color",
-  interval: "color",
-  opacity: "opacity"
-});
-
 export const removeLegend = action(
   { op: "removeLegend", description: "Remove every legend block owned by one mark." },
   function (args = {}) {
     validateKeys(args, OPTIONS, "removeLegend");
-    const target = resolveTarget(this, args.target);
+    const target = resolveLegendTarget(this, args.target, "removeLegend");
     const kinds = Object.entries(this.guideConfigs.legend ?? {})
       .filter(([, config]) => config?.target === target)
       .map(([kind]) => kind);
-    const semanticKinds = new Set(kinds.map(kind => SEMANTIC_KIND[kind]));
+    const semanticKinds = new Set(
+      kinds.map(kind => legendResourcePolicy(kind).semanticKind)
+    );
     let next = this;
     for (const kind of semanticKinds) {
       if (next.semanticSpec.guides.legend?.[kind] !== undefined) {

package/src/actions/guides/legends/size.js

@@ -1,6 +1,6 @@
 import { action } from "../../../core/action.js";
 import { validateKeys } from "../../../core/validation.js";
-import { mapLinearValues } from "../../../grammar/scales.js";
+import { mapLinearValues } from "../../../grammar/scales/index.js";
 import { resolveGraphicBounds } from "../../../layout/canvas.js";
 import { DEFAULT_COLORS, DEFAULT_FONT_FAMILY } from
   "../../../theme/defaults.js";

package/src/actions/guides/legends/strokeWidth.js

@@ -0,0 +1,170 @@
+import { action } from "../../../core/action.js";
+import { validateKeys } from "../../../core/validation.js";
+import { mapContinuousScaleValues } from "../../../grammar/scales/index.js";
+import { resolveGraphicBounds } from "../../../layout/canvas.js";
+import { resolveLegendGraphicPlacement } from
+  "../../../materialization/graphicHierarchy.js";
+import { findLayer } from "../../../selectors/layers.js";
+import { DEFAULT_COLORS, DEFAULT_FONT_FAMILY } from
+  "../../../theme/defaults.js";
+
+const OPTIONS = Object.freeze(["target", "count"]);
+
+export function isStrokeWidthLegendLayer(layer) {
+  return ["line", "rule"].includes(layer?.mark?.type) &&
+    layer.encoding?.strokeWidth?.scale !== undefined;
+}
+
+function resolveLayer(program, requested) {
+  const candidates = program.semanticSpec.layers.filter(isStrokeWidthLegendLayer);
+  const layer = requested === undefined
+    ? candidates.length === 1 ? candidates[0] : undefined
+    : (() => {
+        const candidate = findLayer(program, requested);
+        return candidates.includes(candidate) ? candidate : undefined;
+      })();
+  if (layer === undefined) {
+    throw new Error(
+      requested === undefined
+        ? "Stroke-width legend requires one eligible line or rule mark or an explicit target."
+        : `Unknown stroke-width legend target "${requested}".`
+    );
+  }
+  return layer;
+}
+
+function requireScale(program, id) {
+  const scale = program.resolvedScales[id];
+  if (scale === undefined || !["linear", "log", "pow", "sqrt", "symlog"].includes(scale.type)) {
+    throw new Error(`Stroke-width legend requires resolved quantitative scale "${id}".`);
+  }
+  return scale;
+}
+
+function styleText(program, id, { title = false } = {}) {
+  return program
+    .editGraphics({ target: id, property: "fill", value: title
+      ? DEFAULT_COLORS.strongText
+      : DEFAULT_COLORS.text })
+    .editGraphics({ target: id, property: "fontSize", value: title ? 13 : 12 })
+    .editGraphics({ target: id, property: "fontFamily", value: DEFAULT_FONT_FAMILY })
+    .editGraphics({ target: id, property: "fontWeight", value: title ? 600 : "normal" })
+    .editGraphics({ target: id, property: "textAlign", value: "left" })
+    .editGraphics({ target: id, property: "textBaseline", value: "middle" });
+}
+
+export const rematerializeStrokeWidthLegend = action(
+  {
+    op: "rematerializeStrokeWidthLegend",
+    description: "Rematerialize a quantitative stroke-width legend."
+  },
+  function (args = {}) {
+    validateKeys(args, [], "rematerializeStrokeWidthLegend");
+    const config = this.guideConfigs.legend?.strokeWidth;
+    if (config === undefined) {
+      throw new Error("Stroke-width legend requires stored configuration.");
+    }
+    const layer = findLayer(this, config.target);
+    const encoding = layer?.encoding?.strokeWidth;
+    if (encoding?.scale === undefined) {
+      throw new Error("Stroke-width legend target requires a strokeWidth encoding.");
+    }
+    const scale = requireScale(this, encoding.scale);
+    const plot = resolveGraphicBounds(this);
+    if (plot === undefined) {
+      throw new Error("Stroke-width legend requires resolved plot bounds.");
+    }
+    const values = Array.from(
+      { length: config.count },
+      (_, index) => scale.domain[0] +
+        index / (config.count - 1) * (scale.domain[1] - scale.domain[0])
+    );
+    const widths = mapContinuousScaleValues(values, scale);
+    const originX = plot.x + plot.width + 30;
+    const titleY = plot.y + 28;
+    const y = values.map((_, index) => titleY + 34 + index * 32);
+    const title = config.inferredTitle === true ? encoding.field : config.title;
+    let next = this
+      .editSemantic({ property: "guide.legend.strokeWidth.scale", value: encoding.scale })
+      .editSemantic({ property: "guide.legend.strokeWidth.title", value: title })
+      ._withLegendConfig("strokeWidth", {
+        ...config,
+        scale: encoding.scale,
+        title,
+        domain: scale.domain
+      })
+      .editGraphics({ target: "strokeWidthLegendSymbols", property: "length", value: values.length })
+      .editGraphics({ target: "strokeWidthLegendSymbols", property: "x1", value: values.map(() => originX) })
+      .editGraphics({ target: "strokeWidthLegendSymbols", property: "x2", value: values.map(() => originX + 32) })
+      .editGraphics({ target: "strokeWidthLegendSymbols", property: "y1", value: y })
+      .editGraphics({ target: "strokeWidthLegendSymbols", property: "y2", value: y })
+      .editGraphics({ target: "strokeWidthLegendSymbols", property: "stroke", value: DEFAULT_COLORS.mark })
+      .editGraphics({ target: "strokeWidthLegendSymbols", property: "strokeWidth", value: widths })
+      .editGraphics({ target: "strokeWidthLegendLabels", property: "length", value: values.length })
+      .editGraphics({ target: "strokeWidthLegendLabels", property: "x", value: values.map(() => originX + 44) })
+      .editGraphics({ target: "strokeWidthLegendLabels", property: "y", value: y })
+      .editGraphics({
+        target: "strokeWidthLegendLabels",
+        property: "text",
+        value: values.map(value => String(+value.toPrecision(3)))
+      })
+      .editGraphics({ target: "strokeWidthLegendTitle", property: "x", value: originX })
+      .editGraphics({ target: "strokeWidthLegendTitle", property: "y", value: titleY })
+      .editGraphics({ target: "strokeWidthLegendTitle", property: "text", value: title });
+    next = styleText(next, "strokeWidthLegendLabels");
+    return styleText(next, "strokeWidthLegendTitle", { title: true });
+  }
+);
+
+export const createStrokeWidthLegend = action(
+  {
+    op: "createStrokeWidthLegend",
+    description: "Create a quantitative stroke-width legend."
+  },
+  function (args = {}) {
+    validateKeys(args, OPTIONS, "createStrokeWidthLegend");
+    const layer = resolveLayer(this, args.target);
+    const encoding = layer.encoding.strokeWidth;
+    requireScale(this, encoding.scale);
+    const count = args.count ?? 5;
+    if (!Number.isInteger(count) || count < 2) {
+      throw new RangeError(
+        "Stroke-width legend count must be an integer of at least 2."
+      );
+    }
+    return this
+      .editSemantic({ property: "guide.legend.strokeWidth.scale", value: encoding.scale })
+      .editSemantic({ property: "guide.legend.strokeWidth.title", value: encoding.field })
+      ._withLegendConfig("strokeWidth", {
+        target: layer.id,
+        scale: encoding.scale,
+        title: encoding.field,
+        inferredTitle: true,
+        count
+      })
+      .createGraphics({
+        id: "strokeWidthLegendSymbols",
+        type: "line",
+        length: count,
+        ...resolveLegendGraphicPlacement(this)
+      })
+      .createGraphics({
+        id: "strokeWidthLegendLabels",
+        type: "text",
+        length: count,
+        ...resolveLegendGraphicPlacement(this)
+      })
+      .createGraphics({
+        id: "strokeWidthLegendTitle",
+        type: "text",
+        ...resolveLegendGraphicPlacement(this)
+      })
+      .rematerializeStrokeWidthLegend();
+  }
+);
+
+export function registerStrokeWidthLegendActions(ProgramClass) {
+  ProgramClass.prototype.createStrokeWidthLegend = createStrokeWidthLegend;
+  ProgramClass.prototype.rematerializeStrokeWidthLegend =
+    rematerializeStrokeWidthLegend;
+}

package/src/actions/guides/legends/target.js

@@ -0,0 +1,25 @@
+import { validateUserId } from "../../../core/identifiers.js";
+
+export function legendTargets(program) {
+  return [...new Set(Object.values(program.guideConfigs.legend ?? {})
+    .map(config => config?.target)
+    .filter(Boolean))];
+}
+
+export function resolveLegendTarget(program, requested, operation) {
+  const targets = legendTargets(program);
+  if (requested !== undefined) {
+    const target = validateUserId(requested, "Legend target id");
+    if (!targets.includes(target)) {
+      throw new Error(`Unknown legend target "${target}".`);
+    }
+    return target;
+  }
+  if (operation === "removeLegend" && targets.length === 0) {
+    throw new Error("removeLegend requires an existing legend.");
+  }
+  if (targets.length !== 1) {
+    throw new Error(`${operation} requires target when the legend is ambiguous.`);
+  }
+  return targets[0];
+}

package/src/actions/guides/polar/{axes.js → axes/index.js}

@@ -3,31 +3,31 @@ import {
   createThetaAxis,
   editRadialAxis,
   editThetaAxis
-} from "./axes/facade.js";
+} from "./facade.js";
 import {
   createRadialAxisLabels,
   createThetaAxisLabels,
   editRadialAxisLabels,
   editThetaAxisLabels
-} from "./axes/labels.js";
+} from "./labels.js";
 import {
   createRadialAxisLine,
   createThetaAxisLine,
   editRadialAxisLine,
   editThetaAxisLine
-} from "./axes/lines.js";
+} from "./lines.js";
 import {
   createRadialAxisTicks,
   createThetaAxisTicks,
   editRadialAxisTicks,
   editThetaAxisTicks
-} from "./axes/ticks.js";
+} from "./ticks.js";
 import {
   createRadialAxisTitle,
   createThetaAxisTitle,
   editRadialAxisTitle,
   editThetaAxisTitle
-} from "./axes/titles.js";
+} from "./titles.js";
 
 export function registerPolarAxisActions(ProgramClass) {
   Object.assign(ProgramClass.prototype, {

package/src/actions/guides/polar/index.js

@@ -1,2 +1,2 @@
 export { registerPolarGridActions } from "./grids.js";
-export { registerPolarAxisActions } from "./axes.js";
+export { registerPolarAxisActions } from "./axes/index.js";

package/src/actions/guides/polar/resolve.js

@@ -10,7 +10,7 @@ import {
   isTransformedScaleType,
   mapContinuousScaleValues,
   mapOrdinalPositionValues
-} from "../../../grammar/scales.js";
+} from "../../../grammar/scales/index.js";
 import { formatTimeTick, formatTimeTicks } from "../../../grammar/ticks.js";
 import { resolveGraphicBounds } from "../../../layout/canvas.js";
 import { findCoordinate } from "../../../selectors/coordinates.js";

package/src/actions/guides/tickValues.js

@@ -3,7 +3,7 @@ import {
   isTransformedScaleType,
   readQuantitativeField,
   transformedTicks
-} from "../../grammar/scales.js";
+} from "../../grammar/scales/index.js";
 import { niceTicks, timeTicks } from "../../grammar/ticks.js";
 import { findDataset } from "../../selectors/datasets.js";
 import { findSemanticScale } from "../../selectors/scales.js";

package/src/actions/index.js

@@ -1,4 +1,5 @@
 import { registerCanvasActions } from "./canvas/index.js";
+import { registerChartActions } from "./charts/index.js";
 import { registerCoordinateActions } from "./coordinates/index.js";
 import { registerCompositionActions } from "./composition/index.js";
 import { registerDataActions } from "./data/index.js";
@@ -8,12 +9,14 @@ import { registerErrorBarActions } from "./errorBars/index.js";
 import { registerFacetActions } from "./facets/index.js";
 import { registerBoxPlotActions } from "./boxPlots/index.js";
 import { registerGuideActions } from "./guides/index.js";
+import { registerGradientPlotActions } from "./gradientPlots/index.js";
 import { registerMarkActions } from "./marks/index.js";
 import { registerPrimitiveActions } from "./primitives/index.js";
 import { registerRegressionActions } from "./regression/index.js";
 import { registerScaleActions } from "./scales/index.js";
 import { registerTitleActions } from "./titles/index.js";
 import { registerSelectionActions } from "./selection/index.js";
+import { registerViolinPlotActions } from "./violinPlots/index.js";
 
 export function registerActions(ProgramClass) {
   registerPrimitiveActions(ProgramClass);
@@ -31,5 +34,8 @@ export function registerActions(ProgramClass) {
   registerErrorBarActions(ProgramClass);
   registerErrorBandActions(ProgramClass);
   registerBoxPlotActions(ProgramClass);
+  registerGradientPlotActions(ProgramClass);
+  registerViolinPlotActions(ProgramClass);
+  registerChartActions(ProgramClass);
   registerSelectionActions(ProgramClass);
 }

package/src/actions/intervals/resolve.js

@@ -3,7 +3,7 @@ import {
   resolveOptionalUserId,
   validateUserId
 } from "../../core/identifiers.js";
-import { readQuantitativeField } from "../../grammar/scales.js";
+import { readQuantitativeField } from "../../grammar/scales/index.js";
 import { findDataset } from "../../selectors/datasets.js";
 import { hasLayer, resolveEligibleLayer } from "../../selectors/layers.js";
 import { findSemanticScale } from "../../selectors/scales.js";