ggaction 0.0.1

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

@@ -0,0 +1,314 @@
+import { action } from "../../../core/action.js";
+import { validateUserId } from "../../../core/identifiers.js";
+import { isPlainObject } from "../../../core/immutable.js";
+import { validateKeys } from "../../../core/validation.js";
+import { normalizeOptions } from "./categorical/options.js";
+import { symbolGraphic } from "./categorical/layout.js";
+import {
+  normalizeContinuousLegend,
+  validatePositive
+} from "./continuous/common.js";
+import { normalizeOpacitySymbol } from "./continuous/opacity.js";
+import { normalizeIntervalLegend } from "./continuous/interval.js";
+import { findLayer } from "../../../selectors/layers.js";
+import { resolveLegendGraphicPlacement } from
+  "../../../materialization/graphicHierarchy.js";
+
+const OPTIONS = Object.freeze([
+  "target", "position", "align", "direction", "columns", "offset",
+  "titlePosition", "title", "symbol", "labels", "titleStyle", "itemGap",
+  "border", "count", "gradient"
+]);
+
+function mergeObject(previous, patch) {
+  return patch === undefined
+    ? previous
+    : { ...previous, ...patch };
+}
+
+function mergeBorder(previous, patch) {
+  if (patch === undefined) return previous;
+  if (patch === false || patch === true) return 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 });
+  if (!exists && shouldExist) {
+    return program.createGraphics({
+      id,
+      ...definition,
+      ...resolveLegendGraphicPlacement(program)
+    });
+  }
+  return program;
+}
+
+function editContinuous(program, kind, previous, args) {
+  const allowed = kind === "gradient"
+    ? ["target", "position", "align", "offset", "title", "labels",
+      "titleStyle", "border", "count", "gradient"]
+    : ["target", "position", "align", "offset", "title", "symbol", "labels",
+      "titleStyle", "itemGap", "border", "count"];
+  for (const key of Object.keys(args)) {
+    if (!allowed.includes(key)) throw new Error(`${kind} legend does not accept ${key}.`);
+  }
+  const titleMode = args.title;
+  const inferredTitle = titleMode === "auto"
+    ? true
+    : typeof titleMode === "string" ? false : previous.inferredTitle;
+  const titleVisible = titleMode === false ? false
+    : titleMode === undefined ? previous.titleVisible !== false : true;
+  const layer = findLayer(program, previous.target);
+  const inferred = layer?.encoding?.[kind === "gradient" ? "color" : "opacity"]?.field;
+  const title = titleMode === "auto"
+    ? inferred
+    : typeof titleMode === "string" ? titleMode : previous.title;
+  const normalized = normalizeContinuousLegend({
+    target: previous.target,
+    position: args.position ?? previous.position,
+    align: args.align ?? previous.align,
+    offset: args.offset ?? previous.offset,
+    count: args.count ?? previous.count,
+    title,
+    labels: mergeObject(previous.labels, args.labels),
+    titleStyle: mergeObject(previous.titleStyle, args.titleStyle),
+    border: mergeBorder(previous.border, args.border),
+    ...(kind === "opacity" ? {
+      itemGap: args.itemGap ?? previous.itemGap,
+      symbol: args.symbol ?? previous.symbol
+    } : {})
+  }, kind);
+  const config = {
+    ...previous,
+    ...normalized,
+    inferredTitle,
+    titleVisible
+  };
+  if (kind === "gradient") {
+    const gradient = mergeObject(previous.gradient, args.gradient);
+    validatePositive(gradient.length, "Gradient length");
+    validatePositive(gradient.thickness, "Gradient thickness");
+    config.gradient = gradient;
+  } else {
+    config.symbol = normalizeOpacitySymbol(args.symbol ?? previous.symbol);
+  }
+  const prefix = kind === "gradient" ? "colorGradient" : "opacityLegend";
+  let next = program;
+  if (titleMode === "auto" || typeof titleMode === "string") {
+    next = next.editSemantic({
+      property: `guide.legend.${kind === "gradient" ? "color" : "opacity"}.title`,
+      value: title
+    });
+  }
+  next = next._withLegendConfig(kind, config);
+  next = reconcileGraphic(next, `${prefix}Background`, config.border !== false, {
+    type: "rect",
+    before: kind === "gradient" ? "colorGradientStrips" : "opacityLegendSymbols"
+  });
+  next = reconcileGraphic(next, `${prefix}Title`, titleVisible, { type: "text" });
+  return kind === "gradient"
+    ? next.rematerializeGradientLegend()
+    : next.rematerializeOpacityLegend();
+}
+
+function editInterval(program, previous, args) {
+  for (const key of Object.keys(args)) {
+    if (![
+      "target", "position", "align", "direction", "offset", "title",
+      "symbol", "labels", "titleStyle", "itemGap", "border"
+    ].includes(key)) {
+      throw new Error(`interval legend does not accept ${key}.`);
+    }
+  }
+  const titleMode = args.title;
+  const layer = findLayer(program, previous.target);
+  const inferredTitle = titleMode === "auto"
+    ? true
+    : typeof titleMode === "string" ? false : previous.inferredTitle;
+  const titleVisible = titleMode === false
+    ? false
+    : titleMode === undefined ? previous.titleVisible !== false : true;
+  const title = titleMode === "auto"
+    ? layer?.encoding?.color?.field
+    : typeof titleMode === "string" ? titleMode : previous.title;
+  const normalized = normalizeIntervalLegend({
+    target: previous.target,
+    position: args.position ?? previous.position,
+    align: args.align ?? previous.align,
+    direction: args.direction ?? previous.direction,
+    offset: args.offset ?? previous.offset,
+    title,
+    symbol: mergeObject(previous.symbol, args.symbol),
+    labels: mergeObject(previous.labels, args.labels),
+    titleStyle: mergeObject(previous.titleStyle, args.titleStyle),
+    itemGap: args.itemGap ?? previous.itemGap,
+    border: mergeBorder(previous.border, args.border)
+  });
+  let next = program._withLegendConfig("interval", {
+    ...previous,
+    ...normalized,
+    inferredTitle,
+    titleVisible
+  });
+  if (titleMode === "auto" || typeof titleMode === "string") {
+    next = next.editSemantic({
+      property: "guide.legend.color.title",
+      value: title
+    });
+  }
+  next = reconcileGraphic(next, "colorLegendTitle", titleVisible, {
+    type: "text"
+  });
+  return next.rematerializeIntervalLegend();
+}
+
+function categoricalSymbolIds(config) {
+  return new Set(config.symbol.layers.map(layer => symbolGraphic(config, layer.type)));
+}
+
+function editCategorical(program, kind, previous, size, args) {
+  if (args.gradient !== undefined) {
+    throw new Error("Categorical legends do not accept gradient.");
+  }
+  if (args.count !== undefined && size === undefined) {
+    throw new Error("Legend count requires an existing size legend.");
+  }
+  const titleMode = args.title;
+  const inferredTitle = titleMode === "auto"
+    ? true
+    : typeof titleMode === "string" ? false : previous.inferredTitle;
+  const titleVisible = titleMode === false ? false
+    : titleMode === undefined ? previous.titleVisible !== false : true;
+  const title = titleMode === "auto"
+    ? previous.field
+    : typeof titleMode === "string" ? titleMode : previous.title;
+  const normalized = normalizeOptions({
+    target: previous.target,
+    channels: previous.channels,
+    position: args.position ?? previous.position,
+    align: args.align ?? previous.align,
+    direction: args.direction ?? (args.position === "left"
+      ? "vertical"
+      : previous.direction),
+    ...(args.columns === undefined && previous.columns === undefined
+      ? {} : { columns: args.columns ?? previous.columns }),
+    offset: args.offset ?? previous.offset,
+    titlePosition: args.titlePosition ?? previous.titlePosition,
+    title,
+    symbol: args.symbol ?? previous.symbol,
+    labels: mergeObject(previous.labels, args.labels),
+    titleStyle: mergeObject(previous.titleStyle, args.titleStyle),
+    itemGap: args.itemGap ?? previous.itemGap,
+    border: mergeBorder(previous.border, args.border)
+  }, kind);
+  const config = {
+    ...previous,
+    ...normalized,
+    inferredTitle,
+    titleVisible
+  };
+  const oldSymbols = categoricalSymbolIds(previous);
+  const newSymbols = categoricalSymbolIds(config);
+  let next = program;
+  if (titleMode === "auto" || typeof titleMode === "string") {
+    next = next.editSemantic({
+      property: `guide.legend.${kind}.title`,
+      value: title
+    });
+  }
+  next = next._withLegendConfig(kind, config);
+  for (const id of oldSymbols) {
+    if (!newSymbols.has(id) && next.graphicSpec.objects[id] !== undefined) {
+      next = next.editGraphics({ target: id, remove: true });
+    }
+  }
+  next = reconcileGraphic(next, `${kind === "series" ? "series" : "color"}LegendBackground`,
+    config.border !== false, {
+      type: "rect",
+      before: [...newSymbols][0]
+    });
+  for (const layer of config.symbol.layers) {
+    const id = symbolGraphic(config, layer.type);
+    if (next.graphicSpec.objects[id] === undefined) {
+      const suffix = { line: "Lines", point: "Points", swatch: "Swatches" }[layer.type];
+      next = next[`createLegendSymbol${suffix}`]();
+    }
+  }
+  const titleId = `${kind === "series" ? "series" : "color"}LegendTitle`;
+  next = reconcileGraphic(next, titleId, titleVisible, {
+    type: "text",
+    ...(next.graphicSpec.objects.sizeLegendSymbols === undefined
+      ? {} : { before: "sizeLegendSymbols" })
+  });
+  if (size !== undefined) {
+    if (args.count !== undefined && (!Number.isInteger(args.count) || args.count < 2)) {
+      throw new RangeError("Size legend count must be an integer of at least 2.");
+    }
+    next = next._withLegendConfig("size", {
+      ...size,
+      count: args.count ?? size.count,
+      inheritAppearance: true
+    });
+  }
+  return next.rematerializeLegend();
+}
+
+export const editLegend = action(
+  { op: "editLegend", description: "Edit one stable legend layout or appearance." },
+  function (args = {}) {
+    if (!isPlainObject(args)) {
+      throw new TypeError("editLegend options must be a plain object.");
+    }
+    validateKeys(args, OPTIONS, "editLegend");
+    const changes = Object.keys(args).filter(key => key !== "target");
+    if (changes.length === 0) {
+      throw new Error("editLegend requires at least one change.");
+    }
+    if (args.title !== undefined && args.title !== false && args.title !== "auto" && (
+      typeof args.title !== "string" || args.title.length === 0
+    )) {
+      throw new TypeError('editLegend title must be a non-empty string, "auto", or false.');
+    }
+    const target = resolveTarget(this, args.target);
+    const configs = this.guideConfigs.legend ?? {};
+    const categoricalKind = ["series", "color"].find(
+      kind => configs[kind]?.target === target
+    );
+    if (categoricalKind !== undefined) {
+      return editCategorical(
+        this,
+        categoricalKind,
+        configs[categoricalKind],
+        configs.size?.target === target ? configs.size : undefined,
+        args
+      );
+    }
+    if (configs.interval?.target === target) {
+      return editInterval(this, configs.interval, args);
+    }
+    const continuousKind = ["gradient", "opacity"].find(
+      kind => configs[kind]?.target === target
+    );
+    return editContinuous(this, continuousKind, configs[continuousKind], args);
+  }
+);

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

@@ -0,0 +1,9 @@
+import { registerCategoricalLegendActions } from "./categorical/index.js";
+import { registerContinuousLegendActions } from "./continuous/index.js";
+import { registerSizeLegendActions } from "./size.js";
+
+export function registerLegendActions(ProgramClass) {
+  registerCategoricalLegendActions(ProgramClass);
+  registerContinuousLegendActions(ProgramClass);
+  registerSizeLegendActions(ProgramClass);
+}

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

@@ -0,0 +1,220 @@
+import { action } from "../../../core/action.js";
+import { validateKeys } from "../../../core/validation.js";
+import { mapLinearValues } from "../../../grammar/scales.js";
+import { resolveGraphicBounds } from "../../../layout/canvas.js";
+import { DEFAULT_COLORS, DEFAULT_FONT_FAMILY } from
+  "../../../theme/defaults.js";
+import { resolveLayout as resolveCategoricalLayout } from
+  "./categorical/layout.js";
+import { findLayer } from "../../../selectors/layers.js";
+import { resolveLegendGraphicPlacement } from
+  "../../../materialization/graphicHierarchy.js";
+
+const SIZE_OPTIONS = Object.freeze(["target", "count"]);
+
+function resolvePoint(program, requested) {
+  const candidates = program.semanticSpec.layers.filter(layer =>
+    layer.mark?.type === "point" &&
+    layer.encoding?.color?.scale !== undefined &&
+    layer.encoding?.shape?.scale !== undefined
+  );
+  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
+        ? "Point series legend requires one eligible point mark."
+        : `Unknown point series legend target "${requested}".`
+    );
+  }
+  if (layer.encoding.color.field !== layer.encoding.shape.field) {
+    throw new Error("Point color and shape legends require the same field.");
+  }
+  return layer;
+}
+
+function requireScale(program, id, type) {
+  const scale = program.resolvedScales[id];
+  if (scale?.type !== type) {
+    throw new Error(`Legend requires resolved ${type} scale "${id}".`);
+  }
+  return scale;
+}
+
+function bounds(program) {
+  const value = resolveGraphicBounds(program);
+  const canvas = program.graphicSpec.objects.canvas;
+  if (
+    value === undefined ||
+    ![value.x, value.y, value.width, value.height].every(Number.isFinite) ||
+    !Number.isFinite(canvas?.properties.width)
+  ) {
+    throw new Error("Legend layout requires Canvas bounds and width.");
+  }
+  return value;
+}
+
+function styleText(program, id, { title = false, style } = {}) {
+  const resolved = style ?? {
+    color: title ? DEFAULT_COLORS.strongText : DEFAULT_COLORS.text,
+    fontSize: title ? 13 : 12,
+    fontFamily: DEFAULT_FONT_FAMILY,
+    fontWeight: title ? 600 : "normal"
+  };
+  return program
+    .editGraphics({
+      target: id,
+      property: "fill",
+      value: resolved.color
+    })
+    .editGraphics({ target: id, property: "fontSize", value: resolved.fontSize })
+    .editGraphics({ target: id, property: "fontFamily", value: resolved.fontFamily })
+    .editGraphics({ target: id, property: "fontWeight", value: resolved.fontWeight })
+    .editGraphics({ target: id, property: "textAlign", value: "left" })
+    .editGraphics({ target: id, property: "textBaseline", value: "middle" });
+}
+
+export const rematerializeSizeLegend = action(
+  {
+    op: "rematerializeSizeLegend",
+    description: "Rematerialize a quantitative point-size legend."
+  },
+  function (args = {}) {
+    validateKeys(args, [], "rematerializeSizeLegend");
+    const config = this.guideConfigs.legend?.size;
+    if (config === undefined) throw new Error("Size legend requires stored configuration.");
+    const layer = findLayer(this, config.target);
+    const encoding = layer?.encoding?.size;
+    if (encoding?.scale === undefined) {
+      throw new Error("Size legend target requires a size encoding.");
+    }
+    const scale = requireScale(this, encoding.scale, "linear");
+    const title = config.inferredTitle === true ? encoding.field : config.title;
+    const currentConfig = {
+      ...config,
+      scale: encoding.scale,
+      title,
+      domain: scale.domain
+    };
+    const plot = bounds(this);
+    const categorical = this.guideConfigs.legend?.series ??
+      this.guideConfigs.legend?.color;
+    const leftLayout = categorical?.position === "left"
+      ? resolveCategoricalLayout(this, categorical).size
+      : undefined;
+    const originX = leftLayout?.titleX ?? plot.x + plot.width + 30;
+    const seriesCount = categorical?.domain.length ?? 0;
+    const titleY = leftLayout?.titleY ?? plot.y + 56 + seriesCount * 34 + 22;
+    const values = Array.from(
+      { length: currentConfig.count },
+      (_, index) => scale.domain[0] +
+        index / (currentConfig.count - 1) * (scale.domain[1] - scale.domain[0])
+    );
+    const areas = mapLinearValues(values, scale.domain, scale.range, {
+      clamp: scale.clamp ?? false
+    });
+    const itemY = leftLayout?.itemY ??
+      values.map((_, index) => titleY + 34 + index * 40);
+    const symbolX = leftLayout?.symbolX ?? values.map(() => originX + 16);
+    const labelX = leftLayout?.labelX ?? values.map(() => originX + 44);
+    let next = this
+      .editSemantic({ property: "guide.legend.size.scale", value: encoding.scale })
+      .editSemantic({ property: "guide.legend.size.title", value: title })
+      ._withLegendConfig("size", currentConfig)
+      .editGraphics({ target: "sizeLegendSymbols", property: "length", value: values.length })
+      .editGraphics({ target: "sizeLegendSymbols", property: "x", value: symbolX })
+      .editGraphics({ target: "sizeLegendSymbols", property: "y", value: itemY })
+      .editGraphics({
+        target: "sizeLegendSymbols",
+        property: "radius",
+        value: areas.map(area => Math.sqrt(area / Math.PI))
+      })
+      .editGraphics({
+        target: "sizeLegendSymbols",
+        property: "fill",
+        value: DEFAULT_COLORS.sizeSymbol
+      })
+      .editGraphics({ target: "sizeLegendSymbols", property: "opacity", value: 0.7 })
+      .editGraphics({ target: "sizeLegendLabels", property: "length", value: values.length })
+      .editGraphics({ target: "sizeLegendLabels", property: "x", value: labelX })
+      .editGraphics({ target: "sizeLegendLabels", property: "y", value: itemY })
+      .editGraphics({
+        target: "sizeLegendLabels",
+        property: "text",
+        value: values.map(value => String(+value.toPrecision(3)))
+      })
+      .editGraphics({ target: "sizeLegendTitle", property: "x", value: originX })
+      .editGraphics({ target: "sizeLegendTitle", property: "y", value: titleY })
+      .editGraphics({ target: "sizeLegendTitle", property: "text", value: title });
+    next = styleText(next, "sizeLegendLabels", {
+      style: currentConfig.inheritAppearance === true
+        ? categorical.labels
+        : undefined
+    });
+    return styleText(next, "sizeLegendTitle", {
+      title: true,
+      style: currentConfig.inheritAppearance === true
+        ? categorical.titleStyle
+        : undefined
+    });
+  }
+);
+
+export const createSizeLegend = action(
+  {
+    op: "createSizeLegend",
+    description: "Create a quantitative equal-area point-size legend."
+  },
+  function (args = {}) {
+    validateKeys(args, [...SIZE_OPTIONS, "inheritAppearance"], "createSizeLegend");
+    const layer = resolvePoint(this, args.target);
+    const encoding = layer.encoding?.size;
+    if (encoding?.scale === undefined) {
+      throw new Error(`Point mark "${layer.id}" requires a size encoding.`);
+    }
+    const scale = requireScale(this, encoding.scale, "linear");
+    const count = args.count ?? 5;
+    if (!Number.isInteger(count) || count < 2) {
+      throw new RangeError("Size legend count must be an integer of at least 2.");
+    }
+    return this
+      .editSemantic({ property: "guide.legend.size.scale", value: encoding.scale })
+      .editSemantic({ property: "guide.legend.size.title", value: encoding.field })
+      ._withLegendConfig("size", {
+        target: layer.id,
+        scale: encoding.scale,
+        title: encoding.field,
+        inferredTitle: true,
+        domain: scale.domain,
+        count,
+        inheritAppearance: args.inheritAppearance === true
+      })
+      .createGraphics({
+        id: "sizeLegendSymbols",
+        type: "circle",
+        length: count,
+        ...resolveLegendGraphicPlacement(this)
+      })
+      .createGraphics({
+        id: "sizeLegendLabels",
+        type: "text",
+        length: count,
+        ...resolveLegendGraphicPlacement(this)
+      })
+      .createGraphics({
+        id: "sizeLegendTitle",
+        type: "text",
+        ...resolveLegendGraphicPlacement(this)
+      })
+      .rematerializeSizeLegend();
+  }
+);
+
+export function registerSizeLegendActions(ProgramClass) {
+  ProgramClass.prototype.createSizeLegend = createSizeLegend;
+  ProgramClass.prototype.rematerializeSizeLegend = rematerializeSizeLegend;
+}

package/src/actions/guides/tickValues.js

@@ -0,0 +1,84 @@
+import { resolveHistogramBins } from "../../grammar/histogram.js";
+import {
+  isTransformedScaleType,
+  readQuantitativeField,
+  transformedTicks
+} from "../../grammar/scales.js";
+import { niceTicks, timeTicks } from "../../grammar/ticks.js";
+import { findDataset } from "../../selectors/datasets.js";
+import { findSemanticScale } from "../../selectors/scales.js";
+
+export const DEFAULT_TICK_COUNT = 5;
+
+export function inferHistogramBoundaries(program, channel, scaleId) {
+  if (channel !== "x") return undefined;
+
+  const consumers = program.semanticSpec.layers.filter(
+    layer =>
+      layer.encoding?.x?.scale === scaleId &&
+      layer.encoding.x.bin !== undefined
+  );
+  if (consumers.length === 0) return undefined;
+  if (consumers.length > 1) {
+    throw new Error(
+      `Guide values cannot infer shared histogram bins for scale "${scaleId}".`
+    );
+  }
+
+  const [layer] = consumers;
+  const encoding = layer.encoding.x;
+  const dataset = findDataset(program, layer.data);
+  const scale = findSemanticScale(program, scaleId);
+  if (dataset === undefined || scale === undefined) {
+    throw new Error(
+      `Guide values require histogram data and scale "${scaleId}".`
+    );
+  }
+
+  return resolveHistogramBins({
+    values: readQuantitativeField(dataset.values, encoding.field),
+    bin: encoding.bin,
+    domain: scale.domain,
+    nice: scale.nice ?? true,
+    zero: scale.zero ?? false
+  }).boundaries;
+}
+
+export function valuesFromTickConfig(program, config) {
+  if (config.mode === "values") return config.values;
+
+  const scale = program.resolvedScales[config.scale];
+  if (scale?.type === "time") return timeTicks(scale.domain, config.count);
+  if (scale?.type === "linear") return niceTicks(scale.domain, config.count);
+  if (isTransformedScaleType(scale?.type)) {
+    return transformedTicks(scale.type, scale.domain, config.count, {
+      ...(scale.base === undefined ? {} : { base: scale.base }),
+      ...(scale.exponent === undefined ? {} : { exponent: scale.exponent }),
+      ...(scale.constant === undefined ? {} : { constant: scale.constant })
+    });
+  }
+  throw new Error(
+    `Guide values require resolved continuous scale "${config.scale}".`
+  );
+}
+
+export function inferGridTickConfig(program, channel, scaleId) {
+  const axis = program.guideConfigs.axis?.[channel]?.ticks;
+  if (axis?.scale === scaleId) {
+    return axis.mode === "values"
+      ? { mode: "values", values: axis.values }
+      : { mode: "count", count: axis.count };
+  }
+
+  const boundaries = inferHistogramBoundaries(program, channel, scaleId);
+  const scale = program.resolvedScales[scaleId];
+  if (
+    boundaries === undefined &&
+    ["ordinal", "band", "point"].includes(scale?.type)
+  ) {
+    return { mode: "values", values: scale.domain };
+  }
+  return boundaries === undefined
+    ? { mode: "count", count: DEFAULT_TICK_COUNT }
+    : { mode: "values", values: boundaries };
+}

package/src/actions/index.js

@@ -0,0 +1,31 @@
+import { registerCanvasActions } from "./canvas/index.js";
+import { registerCoordinateActions } from "./coordinates/index.js";
+import { registerDataActions } from "./data/index.js";
+import { registerEncodingActions } from "./encodings/index.js";
+import { registerErrorBandActions } from "./errorBands/index.js";
+import { registerErrorBarActions } from "./errorBars/index.js";
+import { registerBoxPlotActions } from "./boxPlots/index.js";
+import { registerGuideActions } from "./guides/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";
+
+export function registerActions(ProgramClass) {
+  registerPrimitiveActions(ProgramClass);
+  registerCanvasActions(ProgramClass);
+  registerDataActions(ProgramClass);
+  registerMarkActions(ProgramClass);
+  registerScaleActions(ProgramClass);
+  registerEncodingActions(ProgramClass);
+  registerCoordinateActions(ProgramClass);
+  registerGuideActions(ProgramClass);
+  registerTitleActions(ProgramClass);
+  registerRegressionActions(ProgramClass);
+  registerErrorBarActions(ProgramClass);
+  registerErrorBandActions(ProgramClass);
+  registerBoxPlotActions(ProgramClass);
+  registerSelectionActions(ProgramClass);
+}