ggaction 0.0.9 → 0.0.11

package/src/grammar/scales/color.js

@@ -1,8 +1,10 @@
 import { cloneAndFreeze, isPlainObject } from "../../core/immutable.js";
+import { validateGeneratedItemLimit } from "../../core/validation.js";
 import {
   normalizePalette,
   resolveContinuousPalette
 } from "../palettes.js";
+import { inverseLerp } from "../numeric.js";
 
 export const CONTINUOUS_COLOR_INTERPOLATIONS = cloneAndFreeze([
   "rgb",
@@ -105,6 +107,10 @@ function rgbToHex({ r, g, b }) {
   ).join("")}`;
 }
 
+function byteChannels({ r, g, b }) {
+  return [r, g, b].map(channel => Math.round(channel * 255));
+}
+
 function rgbToHsl({ r, g, b }) {
   const maximum = Math.max(r, g, b);
   const minimum = Math.min(r, g, b);
@@ -213,10 +219,6 @@ function interpolateHue(left, right, amount, long) {
 }
 
 function mix(left, right, amount, method) {
-  const linear = key => left[key] + (right[key] - left[key]) * amount;
-  if (method === "rgb") {
-    return { r: linear("r"), g: linear("g"), b: linear("b") };
-  }
   if (method.startsWith("hsl")) {
     const a = rgbToHsl(left);
     const b = rgbToHsl(right);
@@ -263,6 +265,7 @@ export function validateContinuousColorInterpolation(value) {
 export function validateSequentialColorRange(value) {
   if (value === "auto") return value;
   if (Array.isArray(value)) {
+    validateGeneratedItemLimit(value.length, "Sequential color range length");
     if (value.length < 2) {
       throw new TypeError("Sequential color range requires at least two colors.");
     }
@@ -293,29 +296,33 @@ export function resolveSequentialColorStops(value) {
     : resolveContinuousPalette(range.palette);
 }
 
+function interpolateColors(colors, position, method, shouldClamp) {
+  const bounded = shouldClamp ? clamp(position) : position;
+  const scaled = bounded * (colors.length - 1);
+  const left = Math.max(0, Math.min(colors.length - 2, Math.floor(scaled)));
+  const right = left + 1;
+  const amount = scaled - left;
+  if (method === "rgb") {
+    const leftChannels = byteChannels(colors[left]);
+    const rightChannels = byteChannels(colors[right]);
+    return `#${leftChannels.map((channel, index) =>
+      Math.round(clamp(
+        channel + (rightChannels[index] - channel) * amount,
+        0,
+        255
+      )).toString(16).padStart(2, "0")
+    ).join("")}`;
+  }
+  return rgbToHex(mix(colors[left], colors[right], amount, method));
+}
+
 export function interpolateColorStops(stops, position, interpolation = "rgb") {
   const method = validateContinuousColorInterpolation(interpolation);
   if (!Array.isArray(stops) || stops.length < 2) {
     throw new TypeError("Color interpolation requires at least two stops.");
   }
   const colors = stops.map(parseColor);
-  const bounded = clamp(position);
-  const scaled = bounded * (colors.length - 1);
-  const left = Math.floor(scaled);
-  const right = Math.min(colors.length - 1, left + 1);
-  if (method === "rgb") {
-    const leftHex = rgbToHex(colors[left]);
-    const rightHex = rgbToHex(colors[right]);
-    const amount = scaled - left;
-    return `#${[1, 3, 5].map(offset =>
-      Math.round(
-        Number.parseInt(leftHex.slice(offset, offset + 2), 16) +
-        (Number.parseInt(rightHex.slice(offset, offset + 2), 16) -
-          Number.parseInt(leftHex.slice(offset, offset + 2), 16)) * amount
-      ).toString(16).padStart(2, "0")
-    ).join("")}`;
-  }
-  return rgbToHex(mix(colors[left], colors[right], scaled - left, method));
+  return interpolateColors(colors, position, method, true);
 }
 
 export function mapSequentialColors(
@@ -337,15 +344,17 @@ export function mapSequentialColors(
   }
   const [start, end] = domain;
   const constant = start === end;
+  const method = validateContinuousColorInterpolation(interpolation);
+  if (!Array.isArray(stops) || stops.length < 2) {
+    throw new TypeError("Color interpolation requires at least two stops.");
+  }
+  const colors = stops.map(parseColor);
   return cloneAndFreeze(values.map(value => {
     if (!Number.isFinite(value)) {
       if (hasUnknown) return options.unknown;
       throw new TypeError("Sequential color values must be finite numbers.");
     }
-    const raw = constant ? 0.5 : (value - start) / (end - start);
-    if (!shouldClamp && (raw < 0 || raw > 1)) {
-      return interpolateColorStops(stops, raw < 0 ? 0 : 1, interpolation);
-    }
-    return interpolateColorStops(stops, clamp(raw), interpolation);
+    const raw = constant ? 0.5 : inverseLerp(value, start, end);
+    return interpolateColors(colors, raw, method, shouldClamp);
   }));
 }

package/src/grammar/scales/continuous.js

@@ -1,5 +1,13 @@
 import { cloneAndFreeze, isPlainObject } from "../../core/immutable.js";
 import { POLAR_POSITION_CHANNELS } from "../../core/vocabulary.js";
+import {
+  alignNumericStep,
+  cleanNumericValue,
+  interpolateNumber,
+  inverseLerp,
+  niceNumericStep,
+  normalizeNumericRange
+} from "../numeric.js";
 import { resolvePolarScaleRange } from "../polar.js";
 import { niceTimeDomain } from "./temporal.js";
 import {
@@ -24,29 +32,48 @@ export function resolveScaleDomain(domain, values) {
   return cloneAndFreeze([minimum, maximum]);
 }
 
-function niceLinearStep(span, count = 5) {
-  const rough = span / Math.max(1, count);
-  const power = 10 ** Math.floor(Math.log10(rough));
-  const fraction = rough / power;
-  const factor = fraction <= 1 ? 1 : fraction <= 2 ? 2 : fraction <= 3 ? 3
-    : fraction <= 5 ? 5 : 10;
-  return factor * power;
-}
-
 export function niceLinearDomain(domain) {
   const [minimum, maximum] = domain;
+  if (minimum === maximum) return cloneAndFreeze([minimum, maximum]);
+
+  const directSpan = maximum - minimum;
   const tolerance = Number.EPSILON * 16 * Math.max(
-    1, Math.abs(minimum), Math.abs(maximum)
+    1,
+    Math.abs(minimum),
+    Math.abs(maximum)
   );
-  if (maximum - minimum <= tolerance) {
-    const midpoint = (minimum + maximum) / 2;
-    return cloneAndFreeze([midpoint, midpoint]);
+  if (Number.isFinite(directSpan) && directSpan > tolerance) {
+    const directStep = niceNumericStep(directSpan);
+    const direct = [
+      Number((Math.floor(minimum / directStep) * directStep).toPrecision(12)),
+      Number((Math.ceil(maximum / directStep) * directStep).toPrecision(12))
+    ];
+    if (
+      direct.every(Number.isFinite) &&
+      direct[0] < direct[1] &&
+      direct[0] <= minimum &&
+      direct[1] >= maximum
+    ) {
+      return cloneAndFreeze(direct);
+    }
   }
-  const step = niceLinearStep(maximum - minimum);
-  return cloneAndFreeze([
-    Number((Math.floor(minimum / step) * step).toPrecision(12)),
-    Number((Math.ceil(maximum / step) * step).toPrecision(12))
-  ]);
+
+  const normalized = normalizeNumericRange(minimum, maximum);
+  const normalizedStep = niceNumericStep(normalized.span);
+  const resolution = normalizedStep * normalized.scale;
+  let lower = cleanNumericValue(
+    alignNumericStep(normalized.start, normalizedStep, "floor") * normalized.scale,
+    resolution
+  );
+  let upper = cleanNumericValue(
+    alignNumericStep(normalized.end, normalizedStep, "ceil") * normalized.scale,
+    resolution
+  );
+
+  if (!Number.isFinite(lower) || lower > minimum) lower = minimum;
+  if (!Number.isFinite(upper) || upper < maximum) upper = maximum;
+  if (lower === upper) return cloneAndFreeze([minimum, maximum]);
+  return cloneAndFreeze([lower, upper]);
 }
 
 export function resolveContinuousDomain({ domain, values, type, nice, zero }) {
@@ -80,9 +107,13 @@ export function resolveScaleRange(range, channel, bounds) {
   ) {
     throw new Error("Automatic position range requires graphical bounds.");
   }
-  return channel === "x"
-    ? cloneAndFreeze([bounds.x, bounds.x + bounds.width])
-    : cloneAndFreeze([bounds.y + bounds.height, bounds.y]);
+  const resolved = channel === "x"
+    ? [bounds.x, bounds.x + bounds.width]
+    : [bounds.y + bounds.height, bounds.y];
+  if (!resolved.every(Number.isFinite)) {
+    throw new RangeError("Automatic position range exceeds the finite numeric range.");
+  }
+  return cloneAndFreeze(resolved);
 }
 
 export function mapLinearValues(values, domain, range, options = {}) {
@@ -97,7 +128,7 @@ export function mapLinearValues(values, domain, range, options = {}) {
     throw new TypeError("Linear scale values must be finite numbers.");
   }
   if (domainStart === domainEnd) {
-    const midpoint = (rangeStart + rangeEnd) / 2;
+    const midpoint = interpolateNumber(rangeStart, rangeEnd, 0.5);
     return cloneAndFreeze(values.map(value =>
       Number.isFinite(value) ? midpoint : options.unknown
     ));
@@ -109,8 +140,24 @@ export function mapLinearValues(values, domain, range, options = {}) {
       if (hasUnknown) return options.unknown;
       throw new TypeError("Linear scale values must be finite numbers.");
     }
-    const proportion = (value - domainStart) / domainSpan;
+    if (value === domainStart) return rangeStart;
+    if (value === domainEnd) return rangeEnd;
+    const directProportion = (value - domainStart) / domainSpan;
+    const directResolved = clamp
+      ? Math.max(0, Math.min(1, directProportion))
+      : directProportion;
+    if (Number.isFinite(domainSpan) && directResolved === 0) return rangeStart;
+    if (Number.isFinite(domainSpan) && directResolved === 1) return rangeEnd;
+    const directValue = rangeStart + directResolved * rangeSpan;
+    if (
+      Number.isFinite(domainSpan) &&
+      Number.isFinite(rangeSpan) &&
+      Number.isFinite(directValue)
+    ) {
+      return directValue;
+    }
+    const proportion = inverseLerp(value, domainStart, domainEnd);
     const resolved = clamp ? Math.max(0, Math.min(1, proportion)) : proportion;
-    return rangeStart + resolved * rangeSpan;
+    return interpolateNumber(rangeStart, rangeEnd, resolved);
   }));
 }

package/src/grammar/scales/definition.js

@@ -118,7 +118,7 @@ export function normalizeScaleDefinition({
     if (type === "pow") definition.exponent = parameters.exponent;
     if (type === "symlog") definition.constant = parameters.constant;
     if (definition.domain !== "auto") {
-      validateTransformedDomain(type, definition.domain, parameters);
+      validateTransformedDomain(type, definition.domain, requested);
     }
   } else {
     for (const property of Object.keys(requested)) {

package/src/grammar/scales/discretized.js

@@ -1,4 +1,6 @@
 import { cloneAndFreeze } from "../../core/immutable.js";
+import { validateGeneratedItemLimit } from "../../core/validation.js";
+import { interpolateNumber } from "../numeric.js";
 import { resolveColorRange, validateColorRange } from "./appearance.js";
 import { SCALE_ROLES, validateScaleTypeForRole } from "./types.js";
 
@@ -35,7 +37,7 @@ function quantile(sorted, probability) {
   const position = (sorted.length - 1) * probability;
   const lower = Math.floor(position);
   const upper = Math.ceil(position);
-  return sorted[lower] + (sorted[upper] - sorted[lower]) * (position - lower);
+  return interpolateNumber(sorted[lower], sorted[upper], position - lower);
 }
 
 export function validateDiscretizedColorDomain(type, domain) {
@@ -62,6 +64,12 @@ export function validateDiscretizedColorDomain(type, domain) {
 }
 
 export function validateDiscretizedColorRange(range) {
+  if (Array.isArray(range)) {
+    validateGeneratedItemLimit(
+      range.length,
+      "Discretized color range length"
+    );
+  }
   const validated = validateColorRange(range);
   if (validated === "auto") return validated;
   if (Array.isArray(validated) && validated.length < 2) {
@@ -76,7 +84,7 @@ export function resolveDiscretizedColorScale({ type, domain, range, values }) {
   const requestedDomain = validateDiscretizedColorDomain(type, domain);
   const sample = [...values].sort((left, right) => left - right);
   const validatedRange = validateDiscretizedColorRange(range);
-  const colorCount = type === "threshold" && requestedDomain !== "auto"
+  const colorCount = type === "threshold"
     ? requestedDomain.length + 1
     : Array.isArray(range) ? range.length : 5;
   const colors = resolveColorRange(
@@ -97,9 +105,20 @@ export function resolveDiscretizedColorScale({ type, domain, range, values }) {
     }
     thresholds = Array.from(
       { length: colors.length - 1 },
-      (_, index) => resolvedDomain[0] + (index + 1) / colors.length *
-        (resolvedDomain[1] - resolvedDomain[0])
+      (_, index) => interpolateNumber(
+        resolvedDomain[0],
+        resolvedDomain[1],
+        (index + 1) / colors.length
+      )
     );
+    if (thresholds.some((value, index) =>
+      value <= (index === 0 ? resolvedDomain[0] : thresholds[index - 1]) ||
+      value >= resolvedDomain[1]
+    )) {
+      throw new RangeError(
+        "Quantize color range requests more classes than its numeric domain can represent."
+      );
+    }
   } else if (type === "quantile") {
     const source = requestedDomain === "auto"
       ? sample
@@ -143,17 +162,28 @@ export function mapDiscretizedColors(values, scale) {
   }));
 }
 
-function formatBoundary(value) {
-  return Number.isInteger(value) ? String(value) : value.toFixed(1);
-}
-
 export function formatDiscretizedIntervals(thresholds) {
   nondecreasing(thresholds, "Discretized color thresholds");
+  let resolution = Infinity;
+  for (let index = 1; index < thresholds.length; index += 1) {
+    const gap = thresholds[index] - thresholds[index - 1];
+    if (Number.isFinite(gap) && gap > 0) resolution = Math.min(resolution, gap);
+  }
+  let labels = thresholds.map(value =>
+    Number.isInteger(value) ? String(value) : value.toFixed(1)
+  );
+  if (thresholds.some((value, index) => {
+    const rounded = Number(labels[index]);
+    return value !== 0 && rounded === 0 ||
+      index > 0 && value !== thresholds[index - 1] &&
+        labels[index] === labels[index - 1] ||
+      !Number.isInteger(value) && Math.abs(rounded - value) > resolution / 4;
+  })) labels = thresholds.map(String);
   return cloneAndFreeze([
-    `< ${formatBoundary(thresholds[0])}`,
-    ...thresholds.slice(0, -1).map((value, index) =>
-      `${formatBoundary(value)}–${formatBoundary(thresholds[index + 1])}`
+    `< ${labels[0]}`,
+    ...labels.slice(0, -1).map((value, index) =>
+      `${value}–${labels[index + 1]}`
     ),
-    `≥ ${formatBoundary(thresholds.at(-1))}`
+    `≥ ${labels.at(-1)}`
   ]);
 }

package/src/grammar/scales/fields.js

@@ -55,8 +55,11 @@ export function readQuantitativeField(rows, field) {
 }
 
 function utcDate(year, month = 1, day = 1) {
-  const timestamp = Date.UTC(year, month - 1, day);
-  const date = new Date(timestamp);
+  const date = new Date(0);
+  date.setUTCFullYear(year, month - 1, day);
+  date.setUTCHours(0, 0, 0, 0);
+  const timestamp = date.getTime();
+  if (!Number.isFinite(timestamp)) return undefined;
   return date.getUTCFullYear() === year &&
     date.getUTCMonth() === month - 1 &&
     date.getUTCDate() === day
@@ -64,6 +67,20 @@ function utcDate(year, month = 1, day = 1) {
     : undefined;
 }
 
+function parseTemporalString(value) {
+  const isoDateTime =
+    /^(\d{4})[-/](\d{2})[-/](\d{2})[T ](\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?)(Z|[+-]\d{2}:?\d{2})?$/iu
+      .exec(value);
+  if (isoDateTime === null) return Date.parse(value);
+  const [, year, month, day, time, zone] = isoDateTime;
+  const normalized = `${year}-${month}-${day}T${time}${zone ?? "Z"}`;
+  return Date.parse(normalized);
+}
+
+function validTimestamp(value) {
+  return Number.isFinite(value) && Number.isFinite(new Date(value).getTime());
+}
+
 export function normalizeTemporalValue(value, field = "value", index = 0) {
   let timestamp;
   if (typeof value === "number") {
@@ -77,9 +94,9 @@ export function normalizeTemporalValue(value, field = "value", index = 0) {
       ? utcDate(Number(year[1]))
       : date !== null
         ? utcDate(Number(date[1]), Number(date[2]), Number(date[3]))
-        : Date.parse(value);
+        : parseTemporalString(value);
   }
-  if (!Number.isFinite(timestamp)) {
+  if (!validTimestamp(timestamp)) {
     throw new TypeError(
       `Field "${field}" must contain a temporal string or finite timestamp ` +
       `(including a valid date or four-digit year) at row ${index}.`

package/src/grammar/scales/ordinal.js

@@ -3,6 +3,54 @@ import { isNominalValue } from "./fields.js";
 import { validateColorRange, validateStrokeDashRange } from "./appearance.js";
 import { validatePair, validateScaleRange } from "./validation.js";
 import { resolveScaleRange } from "./continuous.js";
+import { interpolateNumber } from "../numeric.js";
+
+function divideRange(range, denominator, label) {
+  const direct = (range[1] - range[0]) / denominator;
+  if (Number.isFinite(direct) && (direct !== 0 || range[0] === range[1])) {
+    return direct;
+  }
+  const step = interpolateNumber(range[0], range[1], 1 / denominator) - range[0];
+  if (!Number.isFinite(step) || (step === 0 && range[0] !== range[1])) {
+    throw new RangeError(`${label} exceeds the finite numeric range.`);
+  }
+  return step;
+}
+
+function requireDistinctPositions(scale, label) {
+  const positions = mapOrdinalPositionValues(scale.domain, scale);
+  if (positions.some((position, index) =>
+    !Number.isFinite(position) ||
+    index > 0 && position === positions[index - 1]
+  )) {
+    throw new RangeError(`${label} cannot represent every domain position.`);
+  }
+}
+
+function finitePosition(value, scale, proportion) {
+  return Number.isFinite(value)
+    ? value
+    : interpolateNumber(scale.range[0], scale.range[1], proportion);
+}
+
+function resolvePositionRange(range, channel, bounds, label) {
+  const resolved = range === "auto" && channel === "y"
+    ? cloneAndFreeze([bounds.y, bounds.y + bounds.height])
+    : resolveScaleRange(range, channel, bounds);
+  if (!resolved.every(Number.isFinite)) {
+    throw new RangeError(`Automatic ${label} range exceeds the finite numeric range.`);
+  }
+  return resolved;
+}
+
+function validateDomainValues(domain, values, unknown, label) {
+  const domainValues = new Set(domain);
+  for (const value of values) {
+    if (!domainValues.has(value) && unknown === undefined) {
+      throw new Error(`Value "${value}" is outside the ${label} domain.`);
+    }
+  }
+}
 
 export function validateOrdinalDomain(domain) {
   if (domain === "auto") return domain;
@@ -21,14 +69,14 @@ export function validateOrdinalDomain(domain) {
 
 export function validateOrdinalRange(range) {
   if (range === "auto") return range;
-  if (Array.isArray(range) && range.length === 2 && range.every(Number.isFinite)) {
-    return cloneAndFreeze(range);
-  }
-  if (Array.isArray(range) && range.every(item => typeof item === "string")) {
-    return validateColorRange(range);
-  }
-  if (Array.isArray(range) && range.every(Array.isArray)) {
-    return validateStrokeDashRange(range);
+  if (Array.isArray(range)) {
+    if (range.length === 2 && range.every(Number.isFinite)) {
+      return cloneAndFreeze(range);
+    }
+    if (range.every(item => typeof item === "string")) {
+      return validateColorRange(range);
+    }
+    if (range.every(Array.isArray)) return validateStrokeDashRange(range);
   }
   return validateColorRange(range);
 }
@@ -51,30 +99,22 @@ export function resolveOrdinalPositionScale({
   unknown
 }) {
   const resolvedDomain = resolveOrdinalDomain(domain, values);
-  const resolvedRange = range === "auto" && channel === "y"
-    ? cloneAndFreeze([bounds.y, bounds.y + bounds.height])
-    : resolveScaleRange(range, channel, bounds);
-  const domainValues = new Set(resolvedDomain);
-  for (const value of values) {
-    if (!domainValues.has(value) && unknown === undefined) {
-      throw new Error(`Value "${value}" is outside the ordinal domain.`);
-    }
-  }
-  const step = (resolvedRange[1] - resolvedRange[0]) / resolvedDomain.length;
-  return cloneAndFreeze({
+  const resolvedRange = resolvePositionRange(range, channel, bounds, "ordinal");
+  validateDomainValues(resolvedDomain, values, unknown, "ordinal");
+  const step = divideRange(
+    resolvedRange,
+    resolvedDomain.length,
+    "Ordinal position step"
+  );
+  const resolved = {
     type: "ordinal",
     domain: resolvedDomain,
     range: resolvedRange,
     step,
     bandwidth: Math.abs(step)
-  });
-}
-
-function validateAlign(value) {
-  if (!Number.isFinite(value) || value < 0 || value > 1) {
-    throw new RangeError("Discrete scale align must be between 0 and 1.");
-  }
-  return value;
+  };
+  requireDistinctPositions(resolved, "Ordinal position range");
+  return cloneAndFreeze(resolved);
 }
 
 export function resolveDiscretePositionScale({
@@ -90,21 +130,17 @@ export function resolveDiscretePositionScale({
   align = 0.5,
   unknown
 }) {
-  if (!["band", "point"].includes(type)) {
+  const band = type === "band";
+  if (!band && type !== "point") {
     throw new Error(`Unsupported discrete position scale type "${type}".`);
   }
   const resolvedDomain = resolveOrdinalDomain(domain, values);
-  const resolvedRange = range === "auto" && channel === "y"
-    ? cloneAndFreeze([bounds.y, bounds.y + bounds.height])
-    : resolveScaleRange(range, channel, bounds);
-  const domainValues = new Set(resolvedDomain);
-  for (const value of values) {
-    if (!domainValues.has(value) && unknown === undefined) {
-      throw new Error(`Value "${value}" is outside the discrete domain.`);
-    }
+  const resolvedRange = resolvePositionRange(range, channel, bounds, "discrete");
+  validateDomainValues(resolvedDomain, values, unknown, "discrete");
+  if (!Number.isFinite(align) || align < 0 || align > 1) {
+    throw new RangeError("Discrete scale align must be between 0 and 1.");
   }
-  validateAlign(align);
-  if (type === "band") {
+  if (band) {
     if (!Number.isFinite(paddingInner) || paddingInner < 0 || paddingInner >= 1) {
       throw new RangeError(
         "Band scale paddingInner must be from 0 (inclusive) to 1 (exclusive)."
@@ -120,20 +156,26 @@ export function resolveDiscretePositionScale({
       "Point scale padding must be a non-negative finite number."
     );
   }
-  const span = Math.abs(resolvedRange[1] - resolvedRange[0]);
   const direction = Math.sign(resolvedRange[1] - resolvedRange[0]) || 1;
   const count = resolvedDomain.length;
-  const denominator = type === "band"
+  const denominator = band
     ? Math.max(1, count - paddingInner + paddingOuter * 2)
     : Math.max(1, count - 1 + padding * 2);
-  const step = direction * span / denominator;
-  const bandwidth = type === "band"
+  const step = divideRange(resolvedRange, denominator, "Discrete position step");
+  const bandwidth = band
     ? Math.abs(step) * (1 - paddingInner)
     : 0;
-  const outerPadding = type === "band" ? paddingOuter : padding;
-  const start = resolvedRange[0] +
+  const outerPadding = band ? paddingOuter : padding;
+  const directStart = resolvedRange[0] +
     direction * Math.abs(step) * outerPadding * 2 * align;
-  return cloneAndFreeze({
+  const start = Number.isFinite(directStart)
+    ? directStart
+    : interpolateNumber(
+      resolvedRange[0],
+      resolvedRange[1],
+      outerPadding * 2 * align / denominator
+    );
+  const resolved = {
     type,
     domain: resolvedDomain,
     range: resolvedRange,
@@ -141,8 +183,10 @@ export function resolveDiscretePositionScale({
     start,
     bandwidth,
     align,
-    ...(type === "band" ? { paddingInner, paddingOuter } : { padding })
-  });
+    ...(band ? { paddingInner, paddingOuter } : { padding })
+  };
+  requireDistinctPositions(resolved, "Discrete position range");
+  return cloneAndFreeze(resolved);
 }
 
 export function resolveOrdinalOffsetScale({
@@ -173,14 +217,16 @@ export function resolveOrdinalOffsetScale({
       "Offset scale paddingOuter must be a non-negative finite number."
     );
   }
-  const domainValues = new Set(resolvedDomain);
-  for (const value of values) {
-    if (!domainValues.has(value)) {
-      throw new Error(`Value "${value}" is outside the ordinal domain.`);
-    }
-  }
-  const step = (resolvedRange[1] - resolvedRange[0]) /
-    Math.max(1, resolvedDomain.length - paddingInner + paddingOuter * 2);
+  validateDomainValues(resolvedDomain, values, undefined, "ordinal");
+  const denominator = Math.max(
+    1,
+    resolvedDomain.length - paddingInner + paddingOuter * 2
+  );
+  const step = divideRange(
+    resolvedRange,
+    denominator,
+    "Offset scale padding must leave a positive bandwidth"
+  );
   const bandwidth = Math.abs(step) * (1 - paddingInner);
   if (!Number.isFinite(bandwidth) || bandwidth <= 0) {
     throw new Error("Offset scale padding must leave a positive bandwidth.");
@@ -206,19 +252,29 @@ export function mapOrdinalPositionValues(values, scale) {
       if (hasUnknown) return scale.unknown;
       throw new Error(`Value "${value}" is outside the ordinal domain.`);
     }
+    const positional = scale.type === "band" || scale.type === "point";
     if (
+      !positional ||
       (scale.type === "band" &&
         scale.paddingInner === 0 &&
         scale.paddingOuter === 0 &&
         scale.align === 0.5) ||
       (scale.type === "point" && scale.padding === 0.5 && scale.align === 0.5)
     ) {
-      return scale.range[0] + (index + 0.5) * scale.step;
-    }
-    if (["band", "point"].includes(scale.type)) {
-      const direction = Math.sign(scale.step) || 1;
-      return scale.start + index * scale.step + direction * scale.bandwidth / 2;
+      const direct = scale.range[0] + (index + 0.5) * scale.step;
+      return finitePosition(direct, scale, (index + 0.5) / scale.domain.length);
     }
-    return scale.range[0] + (index + 0.5) * scale.step;
+    const direction = Math.sign(scale.step) || 1;
+    const direct = scale.start + index * scale.step +
+      direction * scale.bandwidth / 2;
+    const band = scale.type === "band";
+    const outer = band ? scale.paddingOuter : scale.padding;
+    const inner = band ? scale.paddingInner : 1;
+    return finitePosition(
+      direct,
+      scale,
+      (outer * 2 * scale.align + index + (1 - inner) / 2) /
+        Math.max(1, scale.domain.length - inner + outer * 2)
+    );
   }));
 }