ggaction 0.0.2 → 0.0.3

package/src/materialization/guides/resources.js

@@ -0,0 +1,46 @@
+const AXIS_COMPONENTS = Object.freeze(["Line", "Ticks", "Labels", "Title"]);
+
+const CATEGORICAL_COMPONENTS = Object.freeze([
+  "Symbols", "SymbolLines", "SymbolPoints", "SymbolSwatches",
+  "Labels", "Title", "Background"
+]);
+
+const LEGEND_GRAPHICS = Object.freeze({
+  series: Object.freeze(CATEGORICAL_COMPONENTS.map(
+    component => `seriesLegend${component}`
+  )),
+  color: Object.freeze(CATEGORICAL_COMPONENTS.map(
+    component => `colorLegend${component}`
+  )),
+  size: Object.freeze([
+    "sizeLegendSymbols", "sizeLegendLabels", "sizeLegendTitle"
+  ]),
+  gradient: Object.freeze([
+    "colorGradientBackground", "colorGradientStrips", "colorGradientTicks",
+    "colorGradientLabels", "colorGradientTitle"
+  ]),
+  interval: Object.freeze([
+    "colorLegendSymbols", "colorLegendLabels", "colorLegendTitle"
+  ]),
+  opacity: Object.freeze([
+    "opacityLegendBackground", "opacityLegendSymbols", "opacityLegendLabels",
+    "opacityLegendTitle"
+  ])
+});
+
+export function axisGraphicIds(channel) {
+  const prefix = channel === "radius" ? "radial" : channel;
+  return AXIS_COMPONENTS.map(component => `${prefix}Axis${component}`);
+}
+
+export function legendGraphicIds(kind) {
+  const ids = LEGEND_GRAPHICS[kind];
+  if (ids === undefined) {
+    throw new Error(`Unknown legend graphic kind "${kind}".`);
+  }
+  return ids;
+}
+
+export function allLegendGraphicIds(kinds) {
+  return [...new Set(kinds.flatMap(legendGraphicIds))];
+}

package/src/materialization/marks.js

@@ -1,23 +1,53 @@
 import { findDataset } from "../selectors/datasets.js";
+import { findLayer } from "../selectors/layers.js";
 import { isAggregate } from "../grammar/aggregate.js";
-import { BAR_GRAINS, resolveBarGrain } from "../grammar/bars/policy.js";
+import {
+  BAR_GRAINS,
+  resolveBarColorLayout,
+  resolveBarOffsetChannel,
+  resolveBarGrain
+} from "../grammar/bars/policy.js";
 import { resolveRuleMode } from "../grammar/rules.js";
 import { findUpstreamTransform } from "./dataProvenance.js";
+import { POSITION_CHANNELS } from "../core/vocabulary.js";
+import { resolveRectMode } from "../grammar/rects.js";
 
-function hasPositionScales(layer) {
+function hasCartesianPositionScales(layer) {
   return (
     layer.encoding?.x?.scale !== undefined &&
     layer.encoding?.y?.scale !== undefined
   );
 }
 
+function hasPolarPositionScales(layer) {
+  return (
+    layer.encoding?.theta?.scale !== undefined &&
+    layer.encoding?.radius?.scale !== undefined
+  );
+}
+
+function hasPositionScales(layer) {
+  return hasCartesianPositionScales(layer);
+}
+
 export function canMaterializePoint(_program, layer) {
-  return layer.mark?.type === "point" && hasPositionScales(layer);
+  return layer.mark?.type === "point" && (
+    hasCartesianPositionScales(layer) || hasPolarPositionScales(layer)
+  );
 }
 
 export function canMaterializeLine(program, layer) {
   const dataset = findDataset(program, layer.data);
   const interval = dataset?.transform?.some(item => item.type === "interval");
+  if (hasPolarPositionScales(layer)) {
+    return (
+      layer.mark?.type === "line" &&
+      ["quantitative", "temporal", "ordinal", "nominal"].includes(
+        layer.encoding.theta.fieldType
+      ) &&
+      layer.encoding.radius.fieldType === "quantitative"
+    );
+  }
   return (
     layer.mark?.type === "line" &&
     hasPositionScales(layer) &&
@@ -50,15 +80,44 @@ export function canMaterializeArea(program, layer) {
   );
 }
 
+export function canMaterializeArc(_program, layer) {
+  if (
+    layer.mark?.type !== "arc" ||
+    layer.encoding?.theta?.scale === undefined ||
+    !["nominal", "ordinal"].includes(layer.encoding.theta.fieldType)
+  ) {
+    return false;
+  }
+  if (layer.encoding.theta.aggregate === "count") {
+    return layer.encoding?.radius === undefined;
+  }
+  return (
+    layer.encoding.theta.aggregate === undefined &&
+    layer.encoding?.radius?.scale !== undefined &&
+    layer.encoding.radius.fieldType === "quantitative"
+  );
+}
+
 export function canMaterializeBar(program, layer) {
   if (layer.mark?.type !== "bar" || !hasPositionScales(layer)) {
     return false;
   }
   const grain = resolveBarGrain(layer);
-  return grain === BAR_GRAINS.histogram || (
-    [BAR_GRAINS.aggregate, BAR_GRAINS.ranged].includes(grain) &&
-    program.markConfigs[layer.id]?.barWidth !== undefined
-  );
+  if (![BAR_GRAINS.histogram, BAR_GRAINS.aggregate, BAR_GRAINS.ranged].includes(grain)) {
+    return false;
+  }
+  if (
+    grain === BAR_GRAINS.aggregate &&
+    resolveBarColorLayout(layer) === "group"
+  ) {
+    const offsetChannel = resolveBarOffsetChannel(layer);
+    return (
+      layer.encoding?.color?.field !== undefined &&
+      layer.encoding?.[offsetChannel]?.field === layer.encoding.color.field &&
+      layer.encoding[offsetChannel].scale !== undefined
+    );
+  }
+  return true;
 }
 
 export function canMaterializeRule(program, layer) {
@@ -71,40 +130,187 @@ export function canMaterializeRule(program, layer) {
   );
 }
 
+export function canMaterializeText(program, layer) {
+  if (layer.mark?.type !== "text" || layer.encoding?.text === undefined) {
+    return false;
+  }
+  if (layer.source !== undefined) {
+    const source = findLayer(program, layer.source);
+    return source !== undefined &&
+      ["point", "bar", "rule", "rect"].includes(source.mark?.type) &&
+      Array.isArray(program.graphicSpec.objects[source.id]?.items);
+  }
+  return hasCartesianPositionScales(layer);
+}
+
+export function canMaterializeRect(_program, layer) {
+  return resolveRectMode(layer) !== undefined;
+}
+
 const MARK_MATERIALIZATION_POLICIES = Object.freeze({
   point: Object.freeze({
     canMaterialize: canMaterializePoint,
-    op: "rematerializePointMark"
+    op: "rematerializePointMark",
+    positionEncoding: Object.freeze({ incomplete: "mark", scaleFirst: true }),
+    encoding: Object.freeze({ scaleFirst: true }),
+    scaleApplication: Object.freeze({
+      deferWithMark: true,
+      position: "rematerialize",
+      deferredChannels: Object.freeze(["size", "shape"]),
+      default: "direct"
+    }),
+    rematerializeIncompleteExisting: true
   }),
   line: Object.freeze({
     canMaterialize: canMaterializeLine,
-    op: "rematerializeLineMark"
+    op: "rematerializeLineMark",
+    positionEncoding: Object.freeze({ incomplete: "scale", scaleFirst: false }),
+    scaleApplication: Object.freeze({ default: "defer" })
   }),
   area: Object.freeze({
     canMaterialize: canMaterializeArea,
-    op: "rematerializeAreaMark"
+    op: "rematerializeAreaMark",
+    positionEncoding: Object.freeze({ incomplete: "scale", scaleFirst: true }),
+    encoding: Object.freeze({ sharedChannels: Object.freeze(["color"]) }),
+    scaleApplication: Object.freeze({ default: "defer" })
+  }),
+  arc: Object.freeze({
+    canMaterialize: canMaterializeArc,
+    op: "rematerializeArcMark",
+    positionEncoding: Object.freeze({ incomplete: "scale", scaleFirst: false }),
+    encoding: Object.freeze({ completeOnly: true }),
+    scaleApplication: Object.freeze({ default: "defer" })
   }),
   bar: Object.freeze({
     canMaterialize: canMaterializeBar,
-    op: "rematerializeBarMark"
+    op: "rematerializeBarMark",
+    positionEncoding: Object.freeze({ incomplete: "scale", scaleFirst: false }),
+    scaleApplication: Object.freeze({ default: "defer" })
   }),
   rule: Object.freeze({
     canMaterialize: canMaterializeRule,
-    op: "rematerializeRuleMark"
+    op: "rematerializeRuleMark",
+    positionEncoding: Object.freeze({ incomplete: "mark", scaleFirst: false }),
+    scaleApplication: Object.freeze({ default: "defer" })
+  }),
+  text: Object.freeze({
+    canMaterialize: canMaterializeText,
+    op: "rematerializeTextMark",
+    positionEncoding: Object.freeze({ incomplete: "mark", scaleFirst: true }),
+    encoding: Object.freeze({ scaleFirst: true }),
+    scaleApplication: Object.freeze({
+      deferWithMark: true,
+      position: "rematerialize",
+      default: "defer"
+    }),
+    rematerializeIncompleteExisting: true,
+    sourceDependent: true
+  }),
+  rect: Object.freeze({
+    canMaterialize: canMaterializeRect,
+    op: "rematerializeRectMark",
+    positionEncoding: Object.freeze({ incomplete: "scale", scaleFirst: true }),
+    encoding: Object.freeze({ scaleFirst: true }),
+    scaleApplication: Object.freeze({
+      deferWithMark: true,
+      position: "rematerialize",
+      default: "defer"
+    }),
+    rematerializeIncompleteExisting: true
   })
 });
 
+function getMarkPolicy(layer) {
+  return MARK_MATERIALIZATION_POLICIES[layer.mark?.type];
+}
+
 export function getMarkRematerializationStep(layer) {
-  const policy = MARK_MATERIALIZATION_POLICIES[layer.mark?.type];
+  const policy = getMarkPolicy(layer);
   return policy === undefined
     ? undefined
     : { op: policy.op, args: { id: layer.id } };
 }
 
 export function getMarkMaterializationStep(program, layer) {
-  const policy = MARK_MATERIALIZATION_POLICIES[layer.mark?.type];
+  const policy = getMarkPolicy(layer);
   if (policy === undefined || !policy.canMaterialize(program, layer)) {
     return undefined;
   }
   return getMarkRematerializationStep(layer);
 }
+
+export function getSourceDependentMarkSteps(program, sourceId) {
+  return program.semanticSpec.layers.flatMap(layer =>
+    layer.source === sourceId && getMarkPolicy(layer)?.sourceDependent === true
+      ? [getMarkMaterializationStep(program, layer)].filter(
+          step => step !== undefined
+        )
+      : []
+  );
+}
+
+export function getPositionEncodingMaterializationSteps(program, layer, scaleId) {
+  const policy = getMarkPolicy(layer);
+  if (policy === undefined) return [];
+  const scale = { op: "rematerializeScale", args: { id: scaleId } };
+  const complete = policy.canMaterialize(program, layer);
+  const mark = getMarkRematerializationStep(layer);
+  if (!complete) {
+    if (policy.positionEncoding.incomplete === "scale") return [scale];
+    return policy.positionEncoding.scaleFirst ? [scale, mark] : [mark];
+  }
+  return policy.positionEncoding.scaleFirst ? [scale, mark] : [mark];
+}
+
+export function getScaleConsumerMaterializationMode(layer, channel) {
+  const policy = getMarkPolicy(layer);
+  if (policy === undefined) return "direct";
+  if (POSITION_CHANNELS.includes(channel)) {
+    return policy.scaleApplication.position ?? policy.scaleApplication.default;
+  }
+  if (policy.scaleApplication.deferredChannels?.includes(channel)) {
+    return "defer";
+  }
+  return policy.scaleApplication.default;
+}
+
+export function canDeferScaleConsumerApplication(layer) {
+  return getMarkPolicy(layer)?.scaleApplication.deferWithMark === true;
+}
+
+export function getExistingMarkRematerializationStep(program, layer) {
+  const policy = getMarkPolicy(layer);
+  if (
+    policy?.rematerializeIncompleteExisting !== true ||
+    program.graphicSpec.objects[layer.id] === undefined
+  ) {
+    return undefined;
+  }
+  return getMarkRematerializationStep(layer);
+}
+
+export function getEncodingMaterializationStages(program, layer, channel, scale) {
+  const policy = getMarkPolicy(layer);
+  if (policy === undefined) return { scales: [], marks: [] };
+  const scales = policy.encoding?.scaleFirst === true && scale !== undefined
+    ? [{
+        op: "rematerializeScale",
+        args: { id: scale, guides: false, marks: false }
+      }]
+    : [];
+  const shared = policy.encoding?.sharedChannels?.includes(channel) === true &&
+    scale !== undefined;
+  const candidates = shared
+    ? program.semanticSpec.layers.filter(candidate =>
+        candidate.mark?.type === layer.mark?.type &&
+        candidate.encoding?.[channel]?.scale === scale
+      )
+    : [layer];
+  const marks = candidates.flatMap(candidate => {
+    const step = policy.encoding?.completeOnly === true
+      ? getMarkMaterializationStep(program, candidate)
+      : getMarkRematerializationStep(candidate);
+    return step === undefined ? [] : [step];
+  });
+  return { scales, marks };
+}

package/src/materialization/planner.js

@@ -6,30 +6,123 @@ const STAGES = Object.freeze([
   "highlights"
 ]);
 
+const STAGE_SET = new Set(STAGES);
+
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+function clonePlanValue(value, path) {
+  if (
+    value === null ||
+    typeof value === "string" ||
+    typeof value === "boolean"
+  ) {
+    return value;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (Array.isArray(value)) {
+    return Object.freeze(value.map((item, index) =>
+      clonePlanValue(item, `${path}[${index}]`)
+    ));
+  }
+  if (isPlainObject(value)) {
+    const clone = {};
+    for (const key of Object.keys(value)) {
+      if (value[key] === undefined) continue;
+      clone[key] = clonePlanValue(value[key], `${path}.${key}`);
+    }
+    return Object.freeze(clone);
+  }
+  throw new TypeError(
+    `${path} must contain only finite JSON-compatible values.`
+  );
+}
+
+function canonicalValue(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map(canonicalValue).join(",")}]`;
+  }
+  if (isPlainObject(value)) {
+    return `{${Object.keys(value).sort().map(key =>
+      `${JSON.stringify(key)}:${canonicalValue(value[key])}`
+    ).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+
+function normalizeStep(step, index) {
+  if (!isPlainObject(step)) {
+    throw new TypeError(`Materialization step ${index} must be a plain object.`);
+  }
+  if (typeof step.op !== "string" || step.op.length === 0) {
+    throw new TypeError(
+      `Materialization step ${index} op must be a non-empty string.`
+    );
+  }
+  if (step.args !== undefined && !isPlainObject(step.args)) {
+    throw new TypeError(
+      `Materialization step ${index} args must be a plain object.`
+    );
+  }
+  return Object.freeze({
+    op: step.op,
+    ...(step.args === undefined
+      ? {}
+      : { args: clonePlanValue(step.args, `Materialization step ${index} args`) })
+  });
+}
+
+function normalizeSteps(steps) {
+  if (!Array.isArray(steps)) {
+    throw new TypeError("Materialization plan stages must be arrays.");
+  }
+  return steps
+    .filter(step => step !== undefined)
+    .map((step, index) => normalizeStep(step, index));
+}
+
 function stepKey(step) {
-  return JSON.stringify([step.op, step.args ?? null]);
+  return `${JSON.stringify(step.op)}:${canonicalValue(step.args ?? null)}`;
 }
 
-export function buildMaterializationPlan(stages = {}) {
+function deduplicateSteps(steps) {
   const plan = [];
   const seen = new Set();
+  for (const step of steps) {
+    const key = stepKey(step);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    plan.push(step);
+  }
+  return Object.freeze(plan);
+}
 
-  for (const stage of STAGES) {
-    for (const step of stages[stage] ?? []) {
-      if (step === undefined) continue;
-      const key = stepKey(step);
-      if (seen.has(key)) continue;
-      seen.add(key);
-      plan.push(step);
+export function buildMaterializationPlan(stages = {}) {
+  if (!isPlainObject(stages)) {
+    throw new TypeError("Materialization plan stages must be a plain object.");
+  }
+  for (const stage of Object.keys(stages)) {
+    if (!STAGE_SET.has(stage)) {
+      throw new Error(`Unknown materialization stage "${stage}".`);
     }
   }
-
-  return plan;
+  return deduplicateSteps(STAGES.flatMap(stage =>
+    normalizeSteps(stages[stage] ?? [])
+  ));
 }
 
 export function applyMaterializationPlan(program, plan) {
+  const steps = deduplicateSteps(normalizeSteps(plan));
   let next = program;
-  for (const step of buildMaterializationPlan({ marks: plan })) {
+  for (const step of steps) {
+    if (typeof next?.[step.op] !== "function") {
+      throw new Error(
+        `Materialization operation "${step.op}" is not available on the program.`
+      );
+    }
     next = step.args === undefined
       ? next[step.op]()
       : next[step.op](step.args);

package/src/materialization/rect.js

@@ -0,0 +1,138 @@
+import {
+  mapOrdinalPositionValues,
+  readScaleField
+} from "../grammar/scales.js";
+import { RECT_MODES, resolveRectMode } from "../grammar/rects.js";
+import { DEFAULT_RECT_MARK } from "./rectConfig.js";
+import { mapScaleConsumerValues } from "./scales/map.js";
+
+function optionalValues(rows, encoding) {
+  return readScaleField(rows, encoding.field, encoding.fieldType, {
+    allowUnknown: true
+  });
+}
+
+function requiredChannels(layer, mode) {
+  return mode === RECT_MODES.ranged
+    ? ["x", "x2", "y", "y2", ...(layer.encoding?.color ? ["color"] : [])]
+    : ["x", "y", ...(layer.encoding?.color ? ["color"] : [])];
+}
+
+export function resolveRectConsumerValues(layer, dataset, channel) {
+  const requested = optionalValues(dataset.values, layer.encoding[channel]);
+  const mode = resolveRectMode(layer);
+  if (mode === undefined) return requested;
+  const complete = requiredChannels(layer, mode).map(candidate =>
+    optionalValues(dataset.values, layer.encoding[candidate])
+  );
+  return requested.map((value, index) =>
+    complete.every(values => values[index] !== undefined) ? value : undefined
+  );
+}
+
+function mapOptional(values, scale, channel, categorical = false) {
+  return values.map(value => {
+    if (value === undefined) return undefined;
+    return categorical
+      ? mapOrdinalPositionValues([value], scale)[0]
+      : mapScaleConsumerValues([value], scale, channel)[0];
+  });
+}
+
+function mappedEncoding(program, layer, dataset, channel) {
+  const encoding = layer.encoding[channel];
+  const scale = program.resolvedScales[encoding.scale];
+  if (scale === undefined) {
+    throw new Error(
+      `Rect mark "${layer.id}" requires resolved ${channel} scale "${encoding.scale}".`
+    );
+  }
+  const values = resolveRectConsumerValues(layer, dataset, channel);
+  const categorical = ["nominal", "ordinal"].includes(encoding.fieldType) &&
+    ["x", "y"].includes(channel);
+  return {
+    values: mapOptional(values, scale, channel, categorical),
+    scale
+  };
+}
+
+function appearance(config, fill) {
+  return {
+    fill,
+    opacity: config.opacity,
+    stroke: config.stroke === false ? "transparent" : config.stroke,
+    strokeWidth: config.stroke === false ? 0 : config.strokeWidth
+  };
+}
+
+export function resolveRectRows(program, layer, dataset) {
+  const mode = resolveRectMode(layer);
+  if (mode === undefined) return [];
+  const x = mappedEncoding(program, layer, dataset, "x");
+  const y = mappedEncoding(program, layer, dataset, "y");
+  const x2 = mode === RECT_MODES.ranged
+    ? mappedEncoding(program, layer, dataset, "x2")
+    : undefined;
+  const y2 = mode === RECT_MODES.ranged
+    ? mappedEncoding(program, layer, dataset, "y2")
+    : undefined;
+  const color = layer.encoding?.color === undefined
+    ? undefined
+    : mappedEncoding(program, layer, dataset, "color").values;
+  const config = program.markConfigs[layer.id] ?? DEFAULT_RECT_MARK;
+
+  return dataset.values.flatMap((row, index) => {
+    const fill = color === undefined ? config.fill : color[index];
+    if (
+      !Number.isFinite(x.values[index]) ||
+      !Number.isFinite(y.values[index]) ||
+      typeof fill !== "string"
+    ) return [];
+
+    let geometry;
+    if (mode === RECT_MODES.discrete) {
+      const width = x.scale.bandwidth;
+      const height = y.scale.bandwidth;
+      if (!Number.isFinite(width) || width <= 0 || !Number.isFinite(height) || height <= 0) {
+        return [];
+      }
+      geometry = {
+        x: x.values[index] - width / 2,
+        y: y.values[index] - height / 2,
+        width,
+        height
+      };
+    } else {
+      const endX = x2.values[index];
+      const endY = y2.values[index];
+      if (!Number.isFinite(endX) || !Number.isFinite(endY)) return [];
+      geometry = {
+        x: Math.min(x.values[index], endX),
+        y: Math.min(y.values[index], endY),
+        width: Math.abs(endX - x.values[index]),
+        height: Math.abs(endY - y.values[index])
+      };
+      if (geometry.width <= 0 || geometry.height <= 0) return [];
+    }
+    return [{
+      row,
+      sourceIndex: index,
+      channels: Object.fromEntries(
+        ["x", "y", "x2", "y2", "color"].flatMap(channel => {
+          const encoding = layer.encoding?.[channel];
+          return encoding?.field === undefined
+            ? []
+            : [[channel, row[encoding.field]]];
+        })
+      ),
+      properties: { ...geometry, ...appearance(config, fill) }
+    }];
+  });
+}
+
+export function resolveRectGraphicItems(program, layer, dataset) {
+  return resolveRectRows(program, layer, dataset).map(item => ({
+    type: "rect",
+    properties: item.properties
+  }));
+}

package/src/materialization/rectConfig.js

@@ -0,0 +1,38 @@
+import {
+  validateNonEmptyString,
+  validateNonNegativeFinite,
+  validateUnitInterval
+} from "../core/validation.js";
+import { DEFAULT_COLORS } from "../theme/defaults.js";
+
+export const DEFAULT_RECT_MARK = Object.freeze({
+  fill: DEFAULT_COLORS.mark,
+  opacity: 1,
+  stroke: "white",
+  strokeWidth: 1
+});
+
+export function normalizeRectMarkConfig(patch, previous = DEFAULT_RECT_MARK) {
+  const result = { ...previous };
+  if (Object.hasOwn(patch, "fill")) {
+    result.fill = validateNonEmptyString(patch.fill, "Rect fill");
+  }
+  if (Object.hasOwn(patch, "opacity")) {
+    result.opacity = validateUnitInterval(patch.opacity, "Rect opacity");
+  }
+  if (Object.hasOwn(patch, "stroke")) {
+    result.stroke = patch.stroke === false
+      ? false
+      : validateNonEmptyString(patch.stroke, "Rect stroke");
+  }
+  if (Object.hasOwn(patch, "strokeWidth")) {
+    if (result.stroke === false) {
+      throw new Error("Rect strokeWidth requires an active stroke.");
+    }
+    result.strokeWidth = validateNonNegativeFinite(
+      patch.strokeWidth,
+      "Rect strokeWidth"
+    );
+  }
+  return Object.freeze(result);
+}

package/src/materialization/rowEncoding.js

@@ -0,0 +1,33 @@
+import { POSITION_CHANNELS } from "../core/vocabulary.js";
+import {
+  mapOrdinalPositionValues,
+  readNominalField,
+  readQuantitativeField,
+  readScaleField,
+  readTemporalField
+} from "../grammar/scales.js";
+import { mapScaleConsumerValues } from "./scales/map.js";
+
+export function resolveRowEncodingValues(program, layer, dataset, channel) {
+  const encoding = layer.encoding?.[channel];
+  if (encoding === undefined) return undefined;
+  const scale = program.resolvedScales[encoding.scale];
+  if (scale === undefined) {
+    throw new Error(
+      `${layer.mark.type} mark "${layer.id}" requires resolved ${channel} scale "${encoding.scale}".`
+    );
+  }
+  const categorical = ["nominal", "ordinal"].includes(encoding.fieldType);
+  const values = Object.hasOwn(scale, "unknown")
+    ? readScaleField(dataset.values, encoding.field, encoding.fieldType, {
+        allowUnknown: true
+      })
+    : categorical
+      ? readNominalField(dataset.values, encoding.field)
+      : encoding.fieldType === "temporal"
+        ? readTemporalField(dataset.values, encoding.field)
+        : readQuantitativeField(dataset.values, encoding.field);
+  return categorical && POSITION_CHANNELS.includes(channel)
+    ? mapOrdinalPositionValues(values, scale)
+    : mapScaleConsumerValues(values, scale, channel);
+}