ggaction 0.0.2 → 0.0.4

package/src/materialization/selection/items/common.js

@@ -0,0 +1,131 @@
+import { cloneAndFreeze, isPlainObject } from "../../../core/immutable.js";
+import { MARK_GRAPHIC_PROPERTIES } from "../../../grammar/markSelection.js";
+import { unionConcreteGraphicBounds } from
+  "../../../grammar/schemas/graphicBounds.js";
+
+export function itemKey(layer, grain, index) {
+  return `${layer.id}/${grain}/${index}`;
+}
+
+function graphicId(layer, index) {
+  return `${layer.id}:${index}`;
+}
+
+function encodingValue(row, encoding) {
+  if (encoding === undefined) return undefined;
+  if (Object.hasOwn(encoding, "field")) return row?.[encoding.field];
+  return encoding.datum;
+}
+
+export function channelMapFromRow(row, layer) {
+  return Object.fromEntries(
+    Object.entries(layer.encoding ?? {})
+      .map(([channel, encoding]) => [channel, encodingValue(row, encoding)])
+      .filter(([, value]) => value !== undefined)
+  );
+}
+
+export function ownFields(row) {
+  return isPlainObject(row) ? { ...row } : {};
+}
+
+export function uniqueFields(rows) {
+  if (rows.length === 0) return {};
+  const fields = new Set(rows.flatMap(row =>
+    isPlainObject(row) ? Object.keys(row) : []
+  ));
+  return Object.fromEntries([...fields].flatMap(field => {
+    if (!rows.every(row => isPlainObject(row) && Object.hasOwn(row, field))) {
+      return [];
+    }
+    const value = rows[0][field];
+    return rows.every(row => row[field] === value) ? [[field, value]] : [];
+  }));
+}
+
+function requireResolvedGraphic(program, layer, type) {
+  const graphic = program.graphicSpec.objects[layer.id];
+  const compatibleCollection = graphic?.type === "collection" &&
+    graphic.items?.every(child => child.type === type);
+  if (
+    (graphic?.type !== type && !compatibleCollection) ||
+    !Array.isArray(graphic.items)
+  ) {
+    throw new Error(
+      `Mark "${layer.id}" requires a materialized ${type} collection for selection.`
+    );
+  }
+  return graphic;
+}
+
+const SELECTABLE_GRAPHIC_PROPERTIES = new Set(MARK_GRAPHIC_PROPERTIES);
+
+export function concreteProperties(properties) {
+  return Object.fromEntries(
+    Object.entries(properties ?? {}).filter(([key, value]) =>
+      SELECTABLE_GRAPHIC_PROPERTIES.has(key) &&
+      (Number.isFinite(value) || typeof value === "string")
+    )
+  );
+}
+
+function sharedConcreteProperties(items) {
+  if (items.length === 0) return {};
+  const shared = concreteProperties(items[0].properties);
+  for (const key of Object.keys(shared)) {
+    if (!items.every(child => child.properties?.[key] === shared[key])) {
+      delete shared[key];
+    }
+  }
+  return shared;
+}
+
+function collectionBounds(program, items) {
+  const bounds = unionConcreteGraphicBounds(
+    program.graphicSpec,
+    items.map(item => item.id)
+  );
+  if (bounds === undefined) return {};
+  const { left, top, right, bottom } = bounds;
+  return { x: left, y: top, width: right - left, height: bottom - top };
+}
+
+export function finalizeItems(program, layer, grain, definitions, graphicType) {
+  const graphic = requireResolvedGraphic(program, layer, graphicType);
+  const referenced = definitions.flatMap((definition, index) =>
+    definition.graphicIndices ?? [index]
+  );
+  if (
+    referenced.some(index => graphic.items[index] === undefined) ||
+    (definitions.every(definition => definition.graphicIndices === undefined) &&
+      graphic.items.length !== definitions.length)
+  ) {
+    throw new Error(
+      `Mark "${layer.id}" item count does not match its materialized graphics.`
+    );
+  }
+  return Object.freeze(definitions.map((definition, index) => {
+    const indices = definition.graphicIndices ?? [index];
+    const items = indices.map(childIndex => graphic.items[childIndex]);
+    const properties = definition.properties ?? (
+      items.length === 1
+        ? concreteProperties(items[0].properties)
+        : {
+            ...sharedConcreteProperties(items),
+            ...collectionBounds(program, items)
+          }
+    );
+    return Object.freeze({
+      key: definition.key ?? itemKey(layer, grain, index),
+      layer: layer.id,
+      markType: layer.mark.type,
+      fields: cloneAndFreeze(definition.fields),
+      channels: cloneAndFreeze(definition.channels),
+      properties: cloneAndFreeze(properties),
+      members: Object.freeze([...definition.members]),
+      graphicIds: Object.freeze(items.map((child, childOffset) =>
+        child.id ?? graphicId(layer, indices[childOffset])
+      ))
+    });
+  }));
+}

package/src/materialization/selection/items/index.js

@@ -0,0 +1,6 @@
+export { resolveAreaItems, resolveLineItems } from "./path.js";
+export { resolveArcItems } from "./arc.js";
+export { resolveBarItems } from "./bar.js";
+export { resolvePointItems } from "./point.js";
+export { resolveRuleItems } from "./rule.js";
+export { resolveRectItems } from "./rect.js";

package/src/materialization/selection/items/path.js

@@ -0,0 +1,59 @@
+import {
+  deriveAreaSeries,
+  deriveDensityAreaSeries
+} from "../../../grammar/areaSeries.js";
+import { deriveLineSeries } from "../../../grammar/lineSeries.js";
+import { findUpstreamTransform } from "../../dataProvenance.js";
+import { finalizeItems, uniqueFields } from "./common.js";
+
+function rowsForSeries(rows, key) {
+  const entries = Object.entries(key);
+  return entries.length === 0
+    ? rows
+    : rows.filter(row => entries.every(([field, value]) => row[field] === value));
+}
+
+function seriesDefinitions(layer, rows, series) {
+  return series.map(item => {
+    const members = rowsForSeries(rows, item.key);
+    const fields = { ...uniqueFields(members), ...item.key };
+    const channels = Object.fromEntries(
+      Object.entries(layer.encoding ?? {}).flatMap(([channel, encoding]) => {
+        if (encoding.field === undefined) {
+          return Object.hasOwn(encoding, "datum")
+            ? [[channel, encoding.datum]]
+            : [];
+        }
+        return Object.hasOwn(fields, encoding.field)
+          ? [[channel, fields[encoding.field]]]
+          : [];
+      })
+    );
+    return { fields, channels, members };
+  });
+}
+
+export function resolveLineItems(program, layer, dataset) {
+  const derived = deriveLineSeries(dataset.values, layer);
+  return finalizeItems(
+    program,
+    layer,
+    "series",
+    seriesDefinitions(layer, dataset.values, derived.series),
+    "path"
+  );
+}
+
+export function resolveAreaItems(program, layer, dataset) {
+  const transform = findUpstreamTransform(program, dataset, "density");
+  const derived = transform === undefined
+    ? deriveAreaSeries(dataset.values, layer)
+    : deriveDensityAreaSeries(dataset.values, layer, transform);
+  return finalizeItems(
+    program,
+    layer,
+    "series",
+    seriesDefinitions(layer, dataset.values, derived.series),
+    "path"
+  );
+}

package/src/materialization/selection/items/point.js

@@ -0,0 +1,55 @@
+import { selectMarkItemKeys } from "../../../grammar/markSelection.js";
+import {
+  channelMapFromRow,
+  concreteProperties,
+  finalizeItems,
+  itemKey,
+  ownFields
+} from "./common.js";
+
+export function resolvePointItems(program, layer, dataset) {
+  const graphic = program.graphicSpec.objects[layer.id];
+  const completePosition = (
+    layer.encoding?.x?.scale !== undefined &&
+    layer.encoding?.y?.scale !== undefined
+  ) || (
+    layer.encoding?.theta?.scale !== undefined &&
+    layer.encoding?.radius?.scale !== undefined
+  );
+  if (
+    !Array.isArray(graphic?.items) ||
+    !completePosition ||
+    (
+      layer.encoding?.size?.scale === undefined &&
+      !Number.isFinite(program.markConfigs[layer.id]?.radius)
+    )
+  ) {
+    throw new Error(`Point mark "${layer.id}" is incomplete for selection.`);
+  }
+  let definitions = dataset.values.map((row, index) => ({
+    key: itemKey(layer, "point", index),
+    fields: ownFields(row),
+    channels: channelMapFromRow(row, layer),
+    properties: concreteProperties(graphic.items[index]?.properties),
+    members: [row]
+  }));
+  for (const config of Object.values(
+    program.materializationConfigs.highlights ?? {}
+  )) {
+    if (config.target !== layer.id || config.bringToFront !== true) continue;
+    const selection = program.materializationConfigs.selections?.[config.selection];
+    if (selection?.target !== layer.id) continue;
+    const selected = new Set(selectMarkItemKeys(definitions, selection.selector));
+    definitions = [
+      ...definitions.filter(definition => !selected.has(definition.key)),
+      ...definitions.filter(definition => selected.has(definition.key))
+    ];
+  }
+  return finalizeItems(
+    program,
+    layer,
+    "point",
+    definitions,
+    program.graphicSpec.objects[layer.id]?.type
+  );
+}

package/src/materialization/selection/items/rect.js

@@ -0,0 +1,23 @@
+import { resolveRectRows } from "../../rect.js";
+import {
+  concreteProperties,
+  finalizeItems,
+  itemKey,
+  ownFields
+} from "./common.js";
+
+export function resolveRectItems(program, layer, dataset) {
+  const graphic = program.graphicSpec.objects[layer.id];
+  if (graphic?.type !== "rect" || !Array.isArray(graphic.items)) {
+    throw new Error(`Rect mark "${layer.id}" is incomplete for selection.`);
+  }
+  const rows = resolveRectRows(program, layer, dataset);
+  const definitions = rows.map((item, graphicIndex) => ({
+    key: itemKey(layer, "rect", item.sourceIndex),
+    fields: ownFields(item.row),
+    channels: item.channels,
+    properties: concreteProperties(graphic.items[graphicIndex]?.properties),
+    members: [item.row]
+  }));
+  return finalizeItems(program, layer, "rect", definitions, "rect");
+}

package/src/materialization/selection/items/rule.js

@@ -0,0 +1,25 @@
+import { deriveRuleValues } from "../../../grammar/rules.js";
+import { finalizeItems, ownFields, uniqueFields } from "./common.js";
+
+export function resolveRuleItems(program, layer, dataset) {
+  const derived = deriveRuleValues(dataset.values, layer);
+  const hasField = Object.values(layer.encoding ?? {}).some(encoding =>
+    Object.hasOwn(encoding, "field")
+  );
+  const definitions = Array.from({ length: derived.length }, (_, index) => {
+    const members = hasField ? [dataset.values[index]] : dataset.values;
+    return {
+      fields: hasField
+        ? ownFields(dataset.values[index])
+        : uniqueFields(dataset.values),
+      channels: Object.fromEntries(
+        Object.entries(derived.values).map(([channel, values]) => [
+          channel,
+          values[index]
+        ])
+      ),
+      members
+    };
+  });
+  return finalizeItems(program, layer, "rule", definitions, "line");
+}

package/src/materialization/selection/policies/arc.js

@@ -0,0 +1,10 @@
+import { resolveArcItems } from "../items/index.js";
+import { normalizeAreaHighlightStyle } from "../styles.js";
+
+export const arcSelectionPolicy = Object.freeze({
+  supportedGrains: Object.freeze(["item"]),
+  resolveItems: resolveArcItems,
+  normalizeHighlightStyle: args => normalizeAreaHighlightStyle(args, "Arc"),
+  applyHighlightOp: "applyPathHighlight",
+  rematerializeOp: "rematerializeArcMark"
+});

package/src/materialization/selection/policies/area.js

@@ -1,4 +1,4 @@
-import { resolveAreaItems } from "../items.js";
+import { resolveAreaItems } from "../items/index.js";
 import { normalizeAreaHighlightStyle } from "../styles.js";
 
 export const areaSelectionPolicy = Object.freeze({

package/src/materialization/selection/policies/bar.js

@@ -1,4 +1,4 @@
-import { resolveBarItems } from "../items.js";
+import { resolveBarItems } from "../items/index.js";
 import { normalizeBarHighlightStyle } from "../styles.js";
 
 export const barSelectionPolicy = Object.freeze({

package/src/materialization/selection/policies/index.js

@@ -1,17 +1,21 @@
 import { findDataset } from "../../../selectors/datasets.js";
 import { requireLayer } from "../../../selectors/layers.js";
 import { areaSelectionPolicy } from "./area.js";
+import { arcSelectionPolicy } from "./arc.js";
 import { barSelectionPolicy } from "./bar.js";
 import { lineSelectionPolicy } from "./line.js";
 import { pointSelectionPolicy } from "./point.js";
 import { ruleSelectionPolicy } from "./rule.js";
+import { rectSelectionPolicy } from "./rect.js";
 
 const POLICIES = Object.freeze({
+  arc: arcSelectionPolicy,
   area: areaSelectionPolicy,
   bar: barSelectionPolicy,
   line: lineSelectionPolicy,
   point: pointSelectionPolicy,
-  rule: ruleSelectionPolicy
+  rule: ruleSelectionPolicy,
+  rect: rectSelectionPolicy
 });
 
 export function findSelectionPolicy(markType) {

package/src/materialization/selection/policies/line.js

@@ -1,4 +1,4 @@
-import { resolveLineItems } from "../items.js";
+import { resolveLineItems } from "../items/index.js";
 import { normalizeStrokeHighlightStyle } from "../styles.js";
 
 export const lineSelectionPolicy = Object.freeze({

package/src/materialization/selection/policies/point.js

@@ -1,4 +1,4 @@
-import { resolvePointItems } from "../items.js";
+import { resolvePointItems } from "../items/index.js";
 import { normalizePointHighlightStyle } from "../styles.js";
 
 export const pointSelectionPolicy = Object.freeze({

package/src/materialization/selection/policies/rect.js

@@ -0,0 +1,10 @@
+import { resolveRectItems } from "../items/index.js";
+import { normalizeRectHighlightStyle } from "../styles.js";
+
+export const rectSelectionPolicy = Object.freeze({
+  supportedGrains: Object.freeze(["item"]),
+  resolveItems: resolveRectItems,
+  normalizeHighlightStyle: normalizeRectHighlightStyle,
+  applyHighlightOp: "applyRectHighlight",
+  rematerializeOp: "rematerializeRectMark"
+});

package/src/materialization/selection/policies/rule.js

@@ -1,4 +1,4 @@
-import { resolveRuleItems } from "../items.js";
+import { resolveRuleItems } from "../items/index.js";
 import { normalizeStrokeHighlightStyle } from "../styles.js";
 
 export const ruleSelectionPolicy = Object.freeze({

package/src/materialization/selection/styles.js

@@ -7,7 +7,7 @@ import {
   validateUnitInterval
 } from "../../core/validation.js";
 import { validatePointShape } from "../../grammar/pointShapes.js";
-import { normalizeStrokeDashPattern } from "../../grammar/scales.js";
+import { normalizeStrokeDashPattern } from "../../grammar/scales/index.js";
 import { DEFAULT_COLORS } from "../../theme/defaults.js";
 
 const DEFAULT_POINT_SIZE = 2;
@@ -80,30 +80,30 @@ export function normalizePointHighlightStyle(args) {
   };
 }
 
-export function normalizeBarHighlightStyle(args) {
+function normalizeRectangularHighlightStyle(args, mark) {
   for (const option of ["shape", "size", "offset", "strokeDash"]) {
     if (args[option] !== undefined) {
-      throw new Error(`Bar highlight does not support ${option}.`);
+      throw new Error(`${mark} highlight does not support ${option}.`);
     }
   }
   if (args.color !== undefined && args.fill !== undefined) {
-    throw new Error("Bar highlight accepts color or fill, not both.");
+    throw new Error(`${mark} highlight accepts color or fill, not both.`);
   }
   const fill = validateNonEmptyString(
     args.fill ?? args.color ?? DEFAULT_COLORS.highlight,
-    "Bar highlight fill"
+    `${mark} highlight fill`
   );
   const opacity = args.opacity === undefined
     ? undefined
-    : validateUnitInterval(args.opacity, "Bar highlight opacity");
+    : validateUnitInterval(args.opacity, `${mark} highlight opacity`);
   const stroke = args.stroke === undefined
     ? undefined
-    : validateNonEmptyString(args.stroke, "Bar highlight stroke");
+    : validateNonEmptyString(args.stroke, `${mark} highlight stroke`);
   const strokeWidth = args.strokeWidth === undefined
     ? undefined
-    : validateNonNegativeFinite(args.strokeWidth, "Bar highlight strokeWidth");
+    : validateNonNegativeFinite(args.strokeWidth, `${mark} highlight strokeWidth`);
   if (strokeWidth !== undefined && stroke === undefined) {
-    throw new Error("Bar highlight strokeWidth requires stroke.");
+    throw new Error(`${mark} highlight strokeWidth requires stroke.`);
   }
   return {
     fill,
@@ -113,6 +113,14 @@ export function normalizeBarHighlightStyle(args) {
   };
 }
 
+export function normalizeBarHighlightStyle(args) {
+  return normalizeRectangularHighlightStyle(args, "Bar");
+}
+
+export function normalizeRectHighlightStyle(args) {
+  return normalizeRectangularHighlightStyle(args, "Rect");
+}
+
 function rejectHighlightOptions(args, mark, options) {
   for (const option of options) {
     if (args[option] !== undefined) {
@@ -154,28 +162,28 @@ export function normalizeStrokeHighlightStyle(args, mark) {
   };
 }
 
-export function normalizeAreaHighlightStyle(args) {
-  rejectHighlightOptions(args, "Area", ["shape", "size", "strokeDash"]);
+export function normalizeAreaHighlightStyle(args, mark = "Area") {
+  rejectHighlightOptions(args, mark, ["shape", "size", "strokeDash"]);
   if (args.color !== undefined && args.fill !== undefined) {
-    throw new Error("Area highlight accepts color or fill, not both.");
+    throw new Error(`${mark} highlight accepts color or fill, not both.`);
   }
   const stroke = args.stroke === undefined
     ? undefined
-    : validateNonEmptyString(args.stroke, "Area highlight stroke");
+    : validateNonEmptyString(args.stroke, `${mark} highlight stroke`);
   const strokeWidth = args.strokeWidth === undefined
     ? undefined
-    : validateNonNegativeFinite(args.strokeWidth, "Area highlight strokeWidth");
+    : validateNonNegativeFinite(args.strokeWidth, `${mark} highlight strokeWidth`);
   if (strokeWidth !== undefined && stroke === undefined) {
-    throw new Error("Area highlight strokeWidth requires stroke.");
+    throw new Error(`${mark} highlight strokeWidth requires stroke.`);
   }
   return {
     fill: validateNonEmptyString(
       args.fill ?? args.color ?? DEFAULT_COLORS.highlight,
-      "Area highlight fill"
+      `${mark} highlight fill`
     ),
     ...(args.opacity === undefined
       ? {}
-      : { opacity: validateUnitInterval(args.opacity, "Area highlight opacity") }),
+      : { opacity: validateUnitInterval(args.opacity, `${mark} highlight opacity`) }),
     ...(stroke === undefined ? {} : { stroke }),
     ...(strokeWidth === undefined ? {} : { strokeWidth }),
     offset: normalizeOffset(args.offset)

package/src/materialization/text.js

@@ -0,0 +1,156 @@
+import { resolveBarChannels } from "../grammar/bars/policy.js";
+import { formatTextValue } from "../grammar/text.js";
+import { findDataset } from "../selectors/datasets.js";
+import { findLayer } from "../selectors/layers.js";
+import { resolveMarkItems } from "./selection/policies/index.js";
+import { mapScaleConsumerValues } from "./scales/map.js";
+import { resolveRowEncodingValues } from "./rowEncoding.js";
+
+function sourceValue(item, source, field) {
+  if (Object.hasOwn(item.fields, field)) return item.fields[field];
+  for (const [channel, encoding] of Object.entries(source.encoding ?? {})) {
+    if (encoding?.field !== field || item.channels[channel] === undefined) continue;
+    if (source.mark.type === "bar" && item.channels[`${channel}2`] !== undefined) {
+      return item.channels[`${channel}2`];
+    }
+    return item.channels[channel];
+  }
+  if (item.members.length === 1 && Object.hasOwn(item.members[0], field)) {
+    return item.members[0][field];
+  }
+  return undefined;
+}
+
+function barAnchor(program, source, item) {
+  const channels = resolveBarChannels(source);
+  const measure = channels.measure;
+  const endpoint = item.channels[`${measure}2`];
+  const scale = program.resolvedScales[source.encoding[measure].scale];
+  const mapped = endpoint === undefined || scale === undefined
+    ? undefined
+    : mapScaleConsumerValues([endpoint], scale, measure)[0];
+  return measure === "x"
+    ? {
+        x: mapped ?? item.properties.x + item.properties.width,
+        y: item.properties.y + item.properties.height / 2
+      }
+    : {
+        x: item.properties.x + item.properties.width / 2,
+        y: mapped ?? item.properties.y
+      };
+}
+
+function sourceAnchor(program, source, item) {
+  if (source.mark.type === "bar") return barAnchor(program, source, item);
+  if (source.mark.type === "rect") {
+    return {
+      x: item.properties.x + item.properties.width / 2,
+      y: item.properties.y + item.properties.height / 2
+    };
+  }
+  if (source.mark.type === "rule") {
+    return {
+      x: item.properties.x2,
+      y: item.properties.y2
+    };
+  }
+  return { x: item.properties.x, y: item.properties.y };
+}
+
+function contentValue(encoding, rowOrItem, source) {
+  return Object.hasOwn(encoding, "field")
+    ? source === undefined
+      ? rowOrItem[encoding.field]
+      : sourceValue(rowOrItem, source, encoding.field)
+    : encoding.datum;
+}
+
+function concreteItem(config, position, value, format) {
+  const text = formatTextValue(value, format);
+  const x = position.x;
+  const y = position.y;
+  if (text === undefined || !Number.isFinite(x) || !Number.isFinite(y)) {
+    return undefined;
+  }
+  return {
+    type: "text",
+    properties: {
+      x: x + config.dx,
+      y: y + config.dy,
+      text,
+      fill: config.fill,
+      opacity: config.opacity,
+      fontSize: config.fontSize,
+      fontFamily: config.fontFamily,
+      fontWeight: config.fontWeight,
+      textAlign: config.align,
+      textBaseline: config.baseline,
+      rotation: config.rotation
+    }
+  };
+}
+
+function relativeLuminance(color) {
+  if (typeof color !== "string" || !/^#[0-9a-f]{6}$/i.test(color)) {
+    return undefined;
+  }
+  const channels = [1, 3, 5].map(offset =>
+    Number.parseInt(color.slice(offset, offset + 2), 16) / 255
+  ).map(value => value <= 0.04045
+    ? value / 12.92
+    : ((value + 0.055) / 1.055) ** 2.4
+  );
+  return 0.2126 * channels[0] + 0.7152 * channels[1] + 0.0722 * channels[2];
+}
+
+function sourceTextConfig(config, source, item) {
+  if (source.mark.type !== "rect" || config.fillExplicit === true) return config;
+  const luminance = relativeLuminance(item.properties.fill);
+  if (luminance === undefined) return config;
+  return {
+    ...config,
+    fill: luminance >= 0.26 ? "#0f172a" : "#f8fafc"
+  };
+}
+
+function resolveSourceTextItems(program, layer, config) {
+  const source = findLayer(program, layer.source);
+  if (source === undefined) {
+    throw new Error(`Text mark "${layer.id}" requires source layer "${layer.source}".`);
+  }
+  const items = resolveMarkItems(program, source.id);
+  return items.flatMap(item => {
+    const concrete = concreteItem(
+      sourceTextConfig(config, source, item),
+      sourceAnchor(program, source, item),
+      contentValue(layer.encoding.text, item, source),
+      layer.encoding.text.format
+    );
+    return concrete === undefined ? [] : [concrete];
+  });
+}
+
+function resolveRowTextItems(program, layer, config) {
+  const dataset = findDataset(program, layer.data);
+  if (dataset === undefined) {
+    throw new Error(`Text mark "${layer.id}" requires an existing dataset.`);
+  }
+  const x = resolveRowEncodingValues(program, layer, dataset, "x");
+  const y = resolveRowEncodingValues(program, layer, dataset, "y");
+  if (x === undefined || y === undefined) return [];
+  return dataset.values.flatMap((row, index) => {
+    const concrete = concreteItem(
+      config,
+      { x: x[index], y: y[index] },
+      contentValue(layer.encoding.text, row),
+      layer.encoding.text.format
+    );
+    return concrete === undefined ? [] : [concrete];
+  });
+}
+
+export function resolveTextGraphicItems(program, layer, config) {
+  return layer.source === undefined
+    ? resolveRowTextItems(program, layer, config)
+    : resolveSourceTextItems(program, layer, config);
+}