ggaction 0.0.2 → 0.0.3

package/src/actions/composition/actions.js

@@ -0,0 +1,247 @@
+import { action } from "../../core/action.js";
+import { ChartProgram as CoreChartProgram } from "../../core/ChartProgram.js";
+import { freezeOwned, isPlainObject } from "../../core/immutable.js";
+import { validateUserId } from "../../core/identifiers.js";
+import { validateOptionObject } from "../../core/validation.js";
+import {
+  normalizeCompositionPadding,
+  resolveCompositionLayout
+} from "../../layout/composition.js";
+import { resolveFacetLayout } from "../../layout/facets.js";
+import { namespaceGraphicSnapshot } from "../../materialization/compositionSnapshot.js";
+import { materializeCompositionGraphics } from
+  "../../materialization/composition.js";
+import { materializeFacetGraphics } from "../../materialization/facets.js";
+
+const CONCAT_OPTIONS = Object.freeze([
+  "id", "programs", "gap", "align", "padding"
+]);
+const LAYOUT_EDIT_OPTIONS = Object.freeze(["gap", "align", "padding"]);
+const REPLACEMENT_OPTIONS = Object.freeze(["target", "program"]);
+
+function normalizeChildEntry(entry, index) {
+  const fallbackId = `view-${index + 1}`;
+  if (entry instanceof CoreChartProgram) {
+    return { id: fallbackId, program: entry };
+  }
+  if (!isPlainObject(entry)) {
+    throw new TypeError(`Composition program ${index} must be a ChartProgram or wrapper.`);
+  }
+  validateOptionObject(entry, ["id", "program"], `Composition program ${index}`);
+  if (!(entry.program instanceof CoreChartProgram)) {
+    throw new TypeError(`Composition program ${index}.program must be a ChartProgram.`);
+  }
+  return {
+    id: entry.id === undefined
+      ? fallbackId
+      : validateUserId(entry.id, "Composition child ID"),
+    program: entry.program
+  };
+}
+
+function childDescriptor({ id, program }) {
+  if (program.actionStack.length !== 0) {
+    throw new Error(`Composition child "${id}" has an unfinished action stack.`);
+  }
+  namespaceGraphicSnapshot(program.graphicSpec, { namespace: id });
+  const canvasId = program.graphicSpec.order.find(
+    graphicId => program.graphicSpec.objects[graphicId]?.type === "canvas"
+  );
+  const canvas = program.graphicSpec.objects[canvasId];
+  const size = program.materializationConfigs.canvas?.size ?? {
+    width: "explicit",
+    height: "explicit"
+  };
+  return {
+    id,
+    width: canvas.properties.width,
+    height: canvas.properties.height,
+    widthMode: size.width,
+    heightMode: size.height
+  };
+}
+
+function normalizeCompositionInput(args, direction) {
+  validateOptionObject(args, CONCAT_OPTIONS, direction === "horizontal" ? "hconcat" : "vconcat");
+  if (!Array.isArray(args.programs) || args.programs.length < 2) {
+    throw new TypeError("Composition requires at least two programs.");
+  }
+  const entries = args.programs.map(normalizeChildEntry);
+  const ids = entries.map(entry => entry.id);
+  if (new Set(ids).size !== ids.length) {
+    throw new Error("Composition child IDs must be unique.");
+  }
+  const id = args.id === undefined
+    ? "composition"
+    : validateUserId(args.id, "Composition ID");
+  const layout = resolveCompositionLayout({
+    direction,
+    children: entries.map(childDescriptor),
+    ...(Object.hasOwn(args, "gap") ? { gap: args.gap } : {}),
+    ...(Object.hasOwn(args, "align") ? { align: args.align } : {}),
+    ...(Object.hasOwn(args, "padding") ? { padding: args.padding } : {})
+  });
+  return {
+    children: freezeOwned(Object.fromEntries(
+      entries.map(entry => [entry.id, entry.program])
+    )),
+    compositionSpec: {
+      id,
+      direction,
+      children: ids,
+      gap: layout.gap,
+      align: layout.align,
+      padding: layout.padding
+    }
+  };
+}
+
+const useProgram = action(
+  {
+    op: "useProgram",
+    description: "Retain one named child program in a composition.",
+    scope: "composition"
+  },
+  function ({ id } = {}) {
+    validateUserId(id, "Composition child ID");
+    if (!Object.hasOwn(this.children, id)) {
+      throw new Error(`Unknown composition child "${id}".`);
+    }
+    return this;
+  }
+);
+
+const materializeComposition = action(
+  {
+    op: "materializeComposition",
+    description: "Materialize retained child programs into one graphic tree.",
+    scope: "composition"
+  },
+  function () {
+    return this.compositionSpec.type === "facet"
+      ? materializeFacetGraphics(this)
+      : materializeCompositionGraphics(this);
+  }
+);
+
+function concatAction(direction, op) {
+  return action(
+    {
+      op,
+      description: direction === "horizontal"
+        ? "Compose complete programs horizontally."
+        : "Compose complete programs vertically."
+    },
+    function (args = {}) {
+      const state = normalizeCompositionInput(args, direction);
+      let next = this._withCompositionState(state);
+      for (const id of state.compositionSpec.children) {
+        next = next.useProgram({ id });
+      }
+      return next.materializeComposition();
+    }
+  );
+}
+
+export const hconcatAction = concatAction("horizontal", "hconcat");
+export const vconcatAction = concatAction("vertical", "vconcat");
+
+const editCompositionLayout = action(
+  {
+    op: "editCompositionLayout",
+    description: "Edit composition spacing and alignment.",
+    scope: "composition"
+  },
+  function (args = {}) {
+    validateOptionObject(args, LAYOUT_EDIT_OPTIONS, "editCompositionLayout");
+    if (!LAYOUT_EDIT_OPTIONS.some(option => Object.hasOwn(args, option))) {
+      throw new TypeError("editCompositionLayout requires at least one layout option.");
+    }
+    const current = this.compositionSpec;
+    if (current.type === "facet") {
+      const layout = resolveFacetLayout({
+        children: current.children.map((id, index) => ({
+          ...childDescriptor({ id, program: this.children[id] }),
+          value: current.facet.values[index]
+        })),
+        columns: current.columns,
+        gap: Object.hasOwn(args, "gap") ? args.gap : current.gap,
+        align: Object.hasOwn(args, "align") ? args.align : current.align,
+        padding: Object.hasOwn(args, "padding")
+          ? normalizeCompositionPadding(args.padding, current.padding)
+          : current.padding,
+        sharedLegend: current.facet.guides.legend === "shared"
+      });
+      return this._withCompositionState({
+        children: this.children,
+        compositionSpec: {
+          ...current,
+          gap: layout.gap,
+          align: layout.align,
+          padding: layout.padding
+        }
+      }).materializeComposition();
+    }
+    const padding = Object.hasOwn(args, "padding")
+      ? normalizeCompositionPadding(args.padding, current.padding)
+      : current.padding;
+    const layout = resolveCompositionLayout({
+      direction: current.direction,
+      children: current.children.map(id => childDescriptor({
+        id,
+        program: this.children[id]
+      })),
+      gap: Object.hasOwn(args, "gap") ? args.gap : current.gap,
+      align: Object.hasOwn(args, "align") ? args.align : current.align,
+      padding
+    });
+    return this._withCompositionState({
+      children: this.children,
+      compositionSpec: {
+        ...current,
+        gap: layout.gap,
+        align: layout.align,
+        padding: layout.padding
+      }
+    }).materializeComposition();
+  }
+);
+
+const replaceCompositionChild = action(
+  {
+    op: "replaceCompositionChild",
+    description: "Replace one composition child without changing its slot.",
+    scope: "composition"
+  },
+  function (args = {}) {
+    validateOptionObject(args, REPLACEMENT_OPTIONS, "replaceCompositionChild");
+    if (this.compositionSpec.type === "facet") {
+      throw new Error("replaceCompositionChild is not available on a facet composition.");
+    }
+    const target = validateUserId(args.target, "Composition child target");
+    if (!Object.hasOwn(this.children, target)) {
+      throw new Error(`Unknown composition child "${target}".`);
+    }
+    if (!(args.program instanceof CoreChartProgram)) {
+      throw new TypeError("replaceCompositionChild program must be a ChartProgram.");
+    }
+    childDescriptor({ id: target, program: args.program });
+    const children = freezeOwned({
+      ...this.children,
+      [target]: args.program
+    });
+    return this._withCompositionState({
+      children,
+      compositionSpec: this.compositionSpec
+    })
+      .useProgram({ id: target })
+      .materializeComposition();
+  }
+);
+
+export function registerCompositionActions(ProgramClass) {
+  ProgramClass.prototype.useProgram = useProgram;
+  ProgramClass.prototype.materializeComposition = materializeComposition;
+  ProgramClass.prototype.editCompositionLayout = editCompositionLayout;
+  ProgramClass.prototype.replaceCompositionChild = replaceCompositionChild;
+}

package/src/actions/composition/index.js

@@ -0,0 +1 @@
+export { registerCompositionActions } from "./actions.js";

package/src/actions/coordinates/actions.js

@@ -3,15 +3,12 @@ import { validateCoordinateType } from "../../grammar/coordinates.js";
 import { validateUserId } from "../../core/identifiers.js";
 import { findCoordinate } from "../../selectors/coordinates.js";
 import { findLayer, hasLayer } from "../../selectors/layers.js";
+import { validateOptionObject } from "../../core/validation.js";
 
 const COORDINATE_OPTIONS = Object.freeze(["id", "type", "layers"]);
 
 function validateOptions(args) {
-  for (const key of Object.keys(args)) {
-    if (!COORDINATE_OPTIONS.includes(key)) {
-      throw new Error(`Unknown createCoordinate option "${key}".`);
-    }
-  }
+  validateOptionObject(args, COORDINATE_OPTIONS, "createCoordinate");
 }
 
 function validateLayers(program, layers) {

package/src/actions/data/density.js

@@ -22,7 +22,13 @@ export const materializeDensityData = action(
     return this
       .editSemantic({
         property: `dataset[${id}].transform`,
-        value: [{ ...transform, bandwidth: result.bandwidth }]
+        value: [{
+          ...transform,
+          resolved: {
+            bandwidth: result.bandwidth,
+            extent: result.extent
+          }
+        }]
       })
       .editSemantic({
         property: `dataset[${id}].values`,

package/src/actions/data/filter.js

@@ -10,6 +10,8 @@ import {
   normalizeMarkFilterTransform
 } from "../../grammar/markFilter.js";
 import { resolveMarkFilterSelection } from "../../materialization/selection/filter.js";
+import { findSelectionPolicy } from
+  "../../materialization/selection/policies/index.js";
 import {
   applyLayerDataRematerialization
 } from "../../materialization/dependencies.js";
@@ -121,7 +123,7 @@ export const filterMarks = action(
       label: "filter mark",
       predicate: candidate =>
         candidate.data !== undefined &&
-        ["point", "bar", "line", "area", "rule"].includes(candidate.mark?.type)
+        findSelectionPolicy(candidate.mark?.type) !== undefined
     });
     const derivedId = `${layer.id}FilteredData`;
     if (hasDataset(this, derivedId)) {

package/src/actions/encodings/appearance.js

@@ -119,6 +119,16 @@ const encodeRadius = action(
   }
 );
 
+const encodePointRadius = action(
+  {
+    op: "encodePointRadius",
+    description: "Set a constant graphical radius on a point mark."
+  },
+  function (args = {}) {
+    return this.encodeRadius(args);
+  }
+);
+
 const encodeSize = action(
   {
     op: "encodeSize",
@@ -236,6 +246,7 @@ const encodeOpacity = action(
 
 export function registerAppearanceEncodingAction(ProgramClass) {
   ProgramClass.prototype.encodeRadius = encodeRadius;
+  ProgramClass.prototype.encodePointRadius = encodePointRadius;
   ProgramClass.prototype.encodeSize = encodeSize;
   ProgramClass.prototype.encodeShape = encodeShape;
   ProgramClass.prototype.encodeOpacity = encodeOpacity;

package/src/actions/encodings/barWidth.js

@@ -3,6 +3,7 @@ import { resolveTarget, validateOptions } from "./shared.js";
 import {
   BAR_GRAINS,
   resolveBarColorLayout,
+  resolveBarOffsetChannel,
   resolveBarGrain
 } from "../../grammar/bars/policy.js";
 import { normalizeBarWidth } from "../../grammar/bars/geometry.js";
@@ -12,7 +13,7 @@ const OPTIONS = Object.freeze(["band", "pixels", "target"]);
 const encodeBarWidth = action(
   {
     op: "encodeBarWidth",
-    description: "Set aggregate bar width within each x band or xOffset slot."
+    description: "Override aggregate or ranged bar width within its category slot."
   },
   function (args = {}) {
     validateOptions(args, OPTIONS, "encodeBarWidth");
@@ -28,6 +29,7 @@ const encodeBarWidth = action(
       this.markConfigs[target]?.barWidth
     );
     const grouped = layout === "group";
+    const offsetChannel = resolveBarOffsetChannel(layer);
     const grain = resolveBarGrain(layer);
     if (grain === BAR_GRAINS.ranged) {
       return this._withMarkConfig(target, { ...this.markConfigs[target], barWidth: width })
@@ -37,11 +39,11 @@ const encodeBarWidth = action(
       grain !== BAR_GRAINS.aggregate ||
       (grouped &&
         layer.encoding?.color?.field !== undefined &&
-        layer.encoding?.xOffset?.field !== layer.encoding.color.field)
+        layer.encoding?.[offsetChannel]?.field !== layer.encoding.color.field)
     ) {
       throw new Error(
         grouped
-          ? "encodeBarWidth requires complete grouped bar x, y, color, and xOffset encodings."
+          ? `encodeBarWidth requires complete grouped bar x, y, color, and ${offsetChannel} encodings.`
           : "encodeBarWidth requires complete aggregate bar x and y encodings."
       );
     }

package/src/actions/encodings/color.js

@@ -4,12 +4,13 @@ import {
   readQuantitativeField,
   readScaleField,
   readTemporalField,
-  validateNominalFieldType
+  validateCategoricalFieldType
 } from "../../grammar/scales.js";
 import {
   BAR_GRAINS,
   inferBarColorLayout,
   resolveBarChannels,
+  resolveBarOffsetChannel,
   resolveBarGrain
 } from "../../grammar/bars/policy.js";
 import { validateColorLayout } from "../../grammar/seriesLayout.js";
@@ -20,6 +21,7 @@ import {
 } from "../../grammar/aggregate.js";
 import {
   resolveColorScaleDefinition,
+  resolveOffsetScaleDefinition,
   resolveQuantitativeColorScaleDefinition
 } from "../scales/definitions.js";
 import {
@@ -33,9 +35,43 @@ import { applyMaterializationPlan } from "../../materialization/dependencies.js"
 import { planEncodingRematerialization } from "../../materialization/encodings.js";
 
 const COLOR_ENCODING_OPTIONS = Object.freeze([
-  "field", "target", "fieldType", "scale", "layout", "aggregate"
+  "field", "target", "fieldType", "scale", "palette", "layout", "aggregate"
 ]);
 
+function resolveColorScaleOptions(args) {
+  const options = args.scale ?? {};
+  if (args.palette === undefined) return options;
+  if (options.palette !== undefined || options.range !== undefined) {
+    throw new Error(
+      "encodeColor palette cannot be combined with scale.palette or scale.range."
+    );
+  }
+  return { ...options, palette: args.palette };
+}
+
+function assertNoConstantColor(program, layer) {
+  const config = program.markConfigs[layer.id];
+  const hasConstant = {
+    point: config?.fill !== undefined,
+    line: config?.stroke !== undefined,
+    bar: config?.barAppearance?.fill !== undefined,
+    arc: config?.fill !== undefined,
+    rect: config?.fillExplicit === true
+  }[layer.mark.type] ?? false;
+  if (hasConstant) {
+    throw new Error(
+      `encodeColor cannot replace constant appearance on ${layer.mark.type} mark "${layer.id}".`
+    );
+  }
+}
+
+function isRangedArea(layer) {
+  return layer.mark.type === "area" && (
+    layer.encoding?.x2 !== undefined ||
+    layer.encoding?.y2 !== undefined
+  );
+}
+
 function resolveColorLayout(layer, requested, barGrain) {
   const existing = layer.encoding?.color === undefined
     ? undefined
@@ -60,15 +96,21 @@ function resolveColorLayout(layer, requested, barGrain) {
         : undefined
   );
 
-  if (["point", "line"].includes(layer.mark.type) && layout !== undefined) {
+  if (["point", "line", "rect"].includes(layer.mark.type) && layout !== undefined) {
     throw new Error(`Color layout is not supported for ${layer.mark.type} marks.`);
   }
   if (layer.mark.type === "area" && layout === "group") {
     throw new Error('Area color layout does not support "group".');
   }
   if (
-    layer.mark.type === "area" &&
-    layer.encoding?.y2 !== undefined &&
+    layer.mark.type === "arc" &&
+    layout !== undefined &&
+    layout !== "overlay"
+  ) {
+    throw new Error('Arc color layout currently supports only "overlay".');
+  }
+  if (
+    isRangedArea(layer) &&
     layout !== "overlay"
   ) {
     throw new Error('Ranged area color encoding supports only "overlay" layout.');
@@ -81,8 +123,9 @@ function applyColorLayoutCompanion(
   { target, layer, layout, scale, field }
 ) {
   if (layout === undefined) return program;
+  if (layer.mark.type === "arc") return program;
   if (layer.mark.type === "bar" && resolveBarGrain(layer) === BAR_GRAINS.ranged) return program;
-  if (layer.mark.type === "area" && layer.encoding?.y2 !== undefined) {
+  if (isRangedArea(layer)) {
     return program;
   }
   const channels = layer.mark.type === "bar" ? resolveBarChannels(layer) : undefined;
@@ -98,16 +141,15 @@ function applyColorLayoutCompanion(
       : "zero";
   let next = program;
   if (layout === "group") {
-    if (channels?.orientation === "horizontal") {
-      throw new Error('Horizontal bars do not support color layout "group" until yOffset is available.');
-    }
-    next = next.encodeXOffset({
+    const offsetChannel = resolveBarOffsetChannel(layer);
+    const method = offsetChannel === "xOffset" ? "encodeXOffset" : "encodeYOffset";
+    next = next[method]({
       field,
       target,
       scale: {
-        ...(layer.encoding?.xOffset?.scale === undefined
+        ...(layer.encoding?.[offsetChannel]?.scale === undefined
           ? {}
-          : { id: layer.encoding.xOffset.scale }),
+          : { id: layer.encoding[offsetChannel].scale }),
         domain: scale.domain
       }
     });
@@ -121,6 +163,40 @@ function applyColorLayoutCompanion(
   });
 }
 
+function preSynchronizeGroupedOffset(
+  program,
+  { target, layer, layout, field, fieldType, scale, requestedScale }
+) {
+  if (
+    layer.mark.type !== "bar" ||
+    layout !== "group" ||
+    layer.encoding?.color?.scale !== scale.id ||
+    !Object.keys(requestedScale).some(key => key !== "id")
+  ) {
+    return program;
+  }
+  const offsetChannel = resolveBarOffsetChannel(layer);
+  const offset = layer.encoding?.[offsetChannel];
+  if (offset?.scale === undefined) return program;
+  const offsetScale = resolveOffsetScaleDefinition(program, {
+    id: offset.scale,
+    domain: scale.domain
+  }, offsetChannel);
+  return program
+    .editSemantic({
+      property: `layer[${target}].encoding.${offsetChannel}.field`,
+      value: field
+    })
+    .editSemantic({
+      property: `layer[${target}].encoding.${offsetChannel}.fieldType`,
+      value: fieldType
+    })
+    .editSemantic({
+      property: `scale[${offsetScale.id}].domain`,
+      value: offsetScale.domain
+    });
+}
+
 function encodeContinuousColor(program, args) {
   if (!["quantitative", "temporal"].includes(args.fieldType)) {
     throw new Error(`Unsupported color field type "${args.fieldType}".`);
@@ -131,12 +207,13 @@ function encodeContinuousColor(program, args) {
   const { id: target, dataset, layer } = resolveTarget(
     program,
     args.target,
-    ["point", "bar"],
+    ["point", "bar", "rect"],
     "continuous color mark"
   );
+  assertNoConstantColor(program, layer);
   const requestedScale = resolveReassignmentScaleOptions(
     layer.encoding?.color,
-    args.scale ?? {}
+    resolveColorScaleOptions(args)
   );
   const scale = resolveQuantitativeColorScaleDefinition(
     program,
@@ -150,16 +227,16 @@ function encodeContinuousColor(program, args) {
   }
   if (
     layer.mark.type === "bar" &&
-    layer.encoding?.color?.fieldType === "nominal"
+    ["nominal", "ordinal"].includes(layer.encoding?.color?.fieldType)
   ) {
     throw new Error(
       "Continuous bar color cannot replace an existing nominal color layout."
     );
   }
   let aggregate;
-  if (layer.mark.type === "point") {
+  if (["point", "rect"].includes(layer.mark.type)) {
     if (args.aggregate !== undefined) {
-      throw new Error("Point continuous color does not support aggregate.");
+      throw new Error(`${layer.mark.type} continuous color does not support aggregate.`);
     }
   } else {
     if (args.fieldType !== "quantitative") {
@@ -184,7 +261,11 @@ function encodeContinuousColor(program, args) {
     validateAggregateFieldType(aggregate, args.fieldType);
     validateAggregateFieldValues(dataset.values, args.field, args.fieldType);
   }
-  if (Object.hasOwn(scale, "unknown")) {
+  if (layer.mark.type === "rect") {
+    readScaleField(dataset.values, args.field, args.fieldType, {
+      allowUnknown: true
+    });
+  } else if (Object.hasOwn(scale, "unknown")) {
     readScaleField(dataset.values, args.field, args.fieldType, {
       allowUnknown: true
     });
@@ -231,22 +312,23 @@ const encodeColor = action(
   function (args = {}) {
     validateOptions(args, COLOR_ENCODING_OPTIONS, "encodeColor");
     const requestedFieldType = args.fieldType ?? "nominal";
-    if (requestedFieldType !== "nominal") {
+    if (!["nominal", "ordinal"].includes(requestedFieldType)) {
       return encodeContinuousColor(this, {
         ...args,
         fieldType: requestedFieldType
       });
     }
     if (args.aggregate !== undefined) {
-      throw new Error("Nominal color does not support aggregate.");
+      throw new Error("Categorical color does not support aggregate.");
     }
-    const fieldType = validateNominalFieldType(requestedFieldType);
+    const fieldType = validateCategoricalFieldType(requestedFieldType);
     const { id: target, dataset, layer } = resolveTarget(
       this,
       args.target,
-      ["point", "line", "bar", "area"],
+      ["point", "line", "bar", "area", "arc", "rect"],
       "color mark"
     );
+    assertNoConstantColor(this, layer);
     if (
       layer.mark.type === "area" &&
       (layer.encoding?.group?.field === undefined ||
@@ -267,15 +349,19 @@ const encodeColor = action(
     const layout = resolveColorLayout(layer, args.layout, barGrain);
     const requestedScale = resolveReassignmentScaleOptions(
       layer.encoding?.color,
-      args.scale ?? {}
+      resolveColorScaleOptions(args)
     );
     const scale = resolveColorScaleDefinition(this, requestedScale);
     if (Object.hasOwn(scale, "unknown") && layer.mark.type !== "point") {
       throw new Error(
-        "Nominal color scale unknown currently requires a row-owned point mark."
+        "Categorical color scale unknown currently requires a row-owned point mark."
       );
     }
-    if (Object.hasOwn(scale, "unknown")) {
+    if (layer.mark.type === "rect") {
+      readScaleField(dataset.values, args.field, fieldType, {
+        allowUnknown: true
+      });
+    } else if (Object.hasOwn(scale, "unknown")) {
       readScaleField(dataset.values, args.field, fieldType, {
         allowUnknown: true
       });
@@ -302,6 +388,15 @@ const encodeColor = action(
         value: layout
       });
     }
+    next = preSynchronizeGroupedOffset(next, {
+      target,
+      layer,
+      layout,
+      field: args.field,
+      fieldType,
+      scale,
+      requestedScale
+    });
     next = applyEncodingScale(next, scale, requestedScale, {
       reassignment: layer.encoding?.color?.scale === scale.id
     });

package/src/actions/encodings/index.js

@@ -8,6 +8,7 @@ import { registerPositionEncodingActions } from "./position.js";
 import { registerRangedEncodingActions } from "./ranged.js";
 import { registerStrokeDashEncodingActions } from "./strokeDash.js";
 import { registerRuleAppearanceEncodingActions } from "./ruleAppearance.js";
+import { registerTextEncodingAction } from "./text.js";
 
 export function registerEncodingActions(ProgramClass) {
   registerPositionEncodingActions(ProgramClass);
@@ -20,4 +21,5 @@ export function registerEncodingActions(ProgramClass) {
   registerStrokeDashEncodingActions(ProgramClass);
   registerAppearanceEncodingAction(ProgramClass);
   registerRuleAppearanceEncodingActions(ProgramClass);
+  registerTextEncodingAction(ProgramClass);
 }