ggaction 0.0.12 → 0.0.15

package/src/grammar/roundedRect.js

@@ -0,0 +1,180 @@
+import { freezeOwned, isPlainObject } from "../core/immutable.js";
+import {
+  requestedStrokeDetails,
+  STROKE_STYLE_PROPERTIES
+} from "./strokeStyle.js";
+
+export const ROUNDED_RECT_K = 4 * (Math.sqrt(2) - 1) / 3;
+export const RECT_STYLE_PROPERTIES = Object.freeze([
+  "cornerRadius",
+  ...STROKE_STYLE_PROPERTIES
+]);
+
+function requireFinite(value, property) {
+  if (!Number.isFinite(value)) {
+    throw new TypeError(`Rounded rect ${property} must be a finite number.`);
+  }
+  return value;
+}
+
+export function validateCornerRadius(value, label = "Rect style") {
+  if (!Number.isFinite(value)) {
+    throw new TypeError(`${label} cornerRadius must be a finite number.`);
+  }
+  if (value < 0) {
+    throw new RangeError(`${label} cornerRadius must not be negative.`);
+  }
+  return value;
+}
+
+export function requestedRectStyleDetails(request = {}, label = "Rect style") {
+  if (!isPlainObject(request)) {
+    throw new TypeError(`${label} details must be a plain object.`);
+  }
+  return freezeOwned({
+    ...requestedStrokeDetails(request, label),
+    ...(Object.hasOwn(request, "cornerRadius")
+      ? { cornerRadius: validateCornerRadius(request.cornerRadius, label) }
+      : {})
+  });
+}
+
+export function normalizeRectGeometry({ x, y, width, height }) {
+  x = requireFinite(x, "x");
+  y = requireFinite(y, "y");
+  width = requireFinite(width, "width");
+  height = requireFinite(height, "height");
+  if (width < 0) {
+    x += width;
+    width = -width;
+  }
+  if (height < 0) {
+    y += height;
+    height = -height;
+  }
+  return freezeOwned({ x, y, width, height });
+}
+
+export function resolveRoundedRectRadius(width, height, requestedRadius) {
+  requireFinite(width, "width");
+  requireFinite(height, "height");
+  validateCornerRadius(requestedRadius, "Rounded rect");
+  if (width < 0 || height < 0) {
+    throw new RangeError("Rounded rect width and height must not be negative.");
+  }
+  return Math.min(requestedRadius, width / 2, height / 2);
+}
+
+export function roundedRectCommands({ x, y, width, height, radius }) {
+  const geometry = normalizeRectGeometry({ x, y, width, height });
+  const r = resolveRoundedRectRadius(
+    geometry.width,
+    geometry.height,
+    radius
+  );
+  if (!(r > 0)) {
+    throw new RangeError("Rounded rect commands require a positive resolved radius.");
+  }
+  const right = geometry.x + geometry.width;
+  const bottom = geometry.y + geometry.height;
+  const c = ROUNDED_RECT_K * r;
+  return freezeOwned([
+    { op: "M", x: geometry.x + r, y: geometry.y },
+    { op: "L", x: right - r, y: geometry.y },
+    {
+      op: "C",
+      x1: right - r + c,
+      y1: geometry.y,
+      x2: right,
+      y2: geometry.y + r - c,
+      x: right,
+      y: geometry.y + r
+    },
+    { op: "L", x: right, y: bottom - r },
+    {
+      op: "C",
+      x1: right,
+      y1: bottom - r + c,
+      x2: right - r + c,
+      y2: bottom,
+      x: right - r,
+      y: bottom
+    },
+    { op: "L", x: geometry.x + r, y: bottom },
+    {
+      op: "C",
+      x1: geometry.x + r - c,
+      y1: bottom,
+      x2: geometry.x,
+      y2: bottom - r + c,
+      x: geometry.x,
+      y: bottom - r
+    },
+    { op: "L", x: geometry.x, y: geometry.y + r },
+    {
+      op: "C",
+      x1: geometry.x,
+      y1: geometry.y + r - c,
+      x2: geometry.x + r - c,
+      y2: geometry.y,
+      x: geometry.x + r,
+      y: geometry.y
+    },
+    { op: "Z" }
+  ].map(command => freezeOwned(command)));
+}
+
+export function materializeRectItem(properties, requestedRadius = 0) {
+  if (!isPlainObject(properties)) {
+    throw new TypeError("Rounded rect item properties must be a plain object.");
+  }
+  const geometry = normalizeRectGeometry(properties);
+  const radius = resolveRoundedRectRadius(
+    geometry.width,
+    geometry.height,
+    requestedRadius
+  );
+  const appearance = Object.fromEntries(Object.entries(properties).filter(
+    ([key]) => !["x", "y", "width", "height"].includes(key)
+  ));
+  return radius === 0
+    ? freezeOwned({
+        type: "rect",
+        properties: freezeOwned({ ...geometry, ...appearance })
+      })
+    : freezeOwned({
+        type: "path",
+        properties: freezeOwned({
+          commands: roundedRectCommands({ ...geometry, radius }),
+          ...appearance
+        })
+      });
+}
+
+export function readRectItemGeometry(item) {
+  if (!isPlainObject(item) || !isPlainObject(item.properties)) return undefined;
+  if (item.type === "rect") {
+    try {
+      return normalizeRectGeometry(item.properties);
+    } catch {
+      return undefined;
+    }
+  }
+  const commands = item.type === "path" ? item.properties.commands : undefined;
+  if (
+    !Array.isArray(commands) ||
+    commands.length !== 10 ||
+    commands.map(command => command?.op).join("") !== "MLCLCLCLCZ"
+  ) return undefined;
+  const geometry = {
+    x: commands[7].x,
+    y: commands[0].y,
+    width: commands[2].x - commands[7].x,
+    height: commands[4].y - commands[0].y
+  };
+  try {
+    return normalizeRectGeometry(geometry);
+  } catch {
+    return undefined;
+  }
+}

package/src/grammar/rules.js

@@ -1,11 +1,9 @@
+import { normalizePositionDatum } from "./positionDatum.js";
 import { cloneAndFreeze } from "../core/immutable.js";
 import {
-  isNominalValue,
-  normalizeTemporalValue,
   readNominalField,
   readQuantitativeField,
-  readTemporalField,
-  validateSemanticFieldType
+  readTemporalField
 } from "./scales/index.js";
 
 const ENDPOINT_CHANNELS = Object.freeze(["x", "y", "x2", "y2"]);
@@ -13,6 +11,7 @@ const VALUE_CHANNELS = Object.freeze([
   ...ENDPOINT_CHANNELS,
   "xOffset",
   "yOffset",
+  "stroke",
   "strokeDash",
   "strokeWidth",
   "opacity"
@@ -39,26 +38,13 @@ function readField(rows, encoding) {
     return readNominalField(rows, encoding.field);
   }
   if (encoding.fieldType === "temporal") {
-    return readTemporalField(rows, encoding.field);
+    return readTemporalField(rows, encoding.field, encoding.temporalUnit);
   }
   return readQuantitativeField(rows, encoding.field);
 }
 
-export function normalizeRuleDatum(value, fieldType, channel) {
-  validateSemanticFieldType(fieldType);
-  if (fieldType === "quantitative") {
-    if (!Number.isFinite(value)) {
-      throw new TypeError(`Rule ${channel} datum must be a finite number.`);
-    }
-    return value;
-  }
-  if (fieldType === "temporal") {
-    return normalizeTemporalValue(value, `${channel} datum`, 0);
-  }
-  if (!isNominalValue(value)) {
-    throw new TypeError(`Rule ${channel} datum must be a nominal value.`);
-  }
-  return value;
+export function normalizeRuleDatum(value, fieldType, channel, temporalUnit) {
+  return normalizePositionDatum(value, fieldType, channel, temporalUnit, "Rule");
 }
 
 export function deriveRuleValues(rows, layer) {
@@ -83,7 +69,8 @@ export function deriveRuleValues(rows, layer) {
       const datum = normalizeRuleDatum(
         encoding.datum,
         encoding.fieldType,
-        channel
+        channel,
+        encoding.temporalUnit
       );
       values[channel] = Array.from({ length }, () => datum);
     }

package/src/grammar/scales/color.js

@@ -325,6 +325,23 @@ export function interpolateColorStops(stops, position, interpolation = "rgb") {
   return interpolateColors(colors, position, method, true);
 }
 
+export function validateSequentialMidpoint(value, type, domain = "auto") {
+  if (value === undefined || value === "auto") return undefined;
+  if (type !== "sequential") {
+    throw new Error(`Scale type "${type}" does not support midpoint.`);
+  }
+  if (!Number.isFinite(value)) {
+    throw new TypeError("Scale midpoint must be finite or auto.");
+  }
+  if (domain !== "auto" && (
+    !Array.isArray(domain) || domain.length !== 2 || !domain.every(Number.isFinite) ||
+    !(value > Math.min(...domain) && value < Math.max(...domain))
+  )) {
+    throw new RangeError("Scale midpoint must lie strictly inside its resolved domain.");
+  }
+  return value;
+}
+
 export function mapSequentialColors(
   values,
   domain,
@@ -342,6 +359,7 @@ export function mapSequentialColors(
   if (typeof shouldClamp !== "boolean") {
     throw new TypeError("Sequential color clamp must be a boolean.");
   }
+  const midpoint = validateSequentialMidpoint(options.midpoint, "sequential", domain);
   const [start, end] = domain;
   const constant = start === end;
   const method = validateContinuousColorInterpolation(interpolation);
@@ -354,7 +372,11 @@ export function mapSequentialColors(
       if (hasUnknown) return options.unknown;
       throw new TypeError("Sequential color values must be finite numbers.");
     }
-    const raw = constant ? 0.5 : inverseLerp(value, start, end);
+    const raw = midpoint === undefined
+      ? constant ? 0.5 : inverseLerp(value, start, end)
+      : (end > start ? value <= midpoint : value >= midpoint)
+        ? inverseLerp(value, start, midpoint) / 2
+        : 0.5 + inverseLerp(value, midpoint, end) / 2;
     return interpolateColors(colors, raw, method, shouldClamp);
   }));
 }

package/src/grammar/scales/colorConsumers.js

@@ -0,0 +1,57 @@
+import { BAR_GRAINS, resolveBarChannels, resolveBarGrain } from "../bars/policy.js";
+import { validateAggregate, validateAggregateFieldType } from "../aggregate.js";
+import { isDiscretizedColorScaleType } from "./types.js";
+
+export function validateContinuousColorConsumer(layer, encoding, scale, {
+  inferAggregate = false,
+  channel = "color"
+} = {}) {
+  const kind = layer.mark?.type;
+  if (channel === "stroke") {
+    if (!["point", "line", "area", "bar", "rect", "arc", "rule", "tick"].includes(kind)) {
+      throw new Error("Continuous stroke requires a supported graphical mark consumer.");
+    }
+    if (!['quantitative', 'temporal'].includes(encoding.fieldType) ||
+      (isDiscretizedColorScaleType(scale.type) && encoding.fieldType !== "quantitative")) {
+      throw new Error(`Scale type "${scale.type}" has an incompatible stroke field type.`);
+    }
+    if (encoding.aggregate !== undefined) {
+      throw new Error("Continuous stroke does not support aggregate.");
+    }
+    if (Object.hasOwn(scale, "unknown") && kind !== "point") {
+      throw new Error("Continuous stroke scale unknown currently requires a row-owned point mark.");
+    }
+    return undefined;
+  }
+  if (!["point", "bar", "rect"].includes(kind)) {
+    throw new Error("Continuous color requires a Point, aggregate Bar, or Rect consumer.");
+  }
+  if (!["quantitative", "temporal"].includes(encoding.fieldType) ||
+    (isDiscretizedColorScaleType(scale.type) && encoding.fieldType !== "quantitative")) {
+    throw new Error(`Scale type "${scale.type}" has an incompatible color field type.`);
+  }
+  if (Object.hasOwn(scale, "unknown") && kind !== "point") {
+    throw new Error("Continuous color scale unknown currently requires a row-owned point mark.");
+  }
+  if (kind !== "bar") {
+    if (encoding.aggregate !== undefined) throw new Error(`${kind} continuous color does not support aggregate.`);
+    return undefined;
+  }
+  if (["nominal", "ordinal"].includes(layer.encoding?.color?.fieldType)) {
+    throw new Error("Continuous bar color cannot replace an existing nominal color layout.");
+  }
+  if (encoding.fieldType !== "quantitative") {
+    throw new Error("Aggregate bar color currently requires a quantitative field.");
+  }
+  if (resolveBarGrain(layer) !== BAR_GRAINS.aggregate) {
+    throw new Error("Continuous bar color requires a complete categorical aggregate bar.");
+  }
+  const measure = layer.encoding?.[resolveBarChannels(layer).measure];
+  const aggregate = encoding.aggregate ?? (inferAggregate && measure?.field === encoding.field ? measure.aggregate : undefined);
+  if (aggregate === undefined) {
+    throw new Error("Continuous bar color requires aggregate when its field differs from the measure field.");
+  }
+  validateAggregate(aggregate);
+  validateAggregateFieldType(aggregate, encoding.fieldType);
+  return aggregate;
+}

package/src/grammar/scales/continuous.js

@@ -94,10 +94,10 @@ export function resolveContinuousDomain({ domain, values, type, nice, zero }) {
   return resolved;
 }
 
-export function resolveScaleRange(range, channel, bounds) {
+export function resolveScaleRange(range, channel, bounds, polarFrame) {
   validatePositionChannel(channel);
   if (POLAR_POSITION_CHANNELS.includes(channel)) {
-    return resolvePolarScaleRange(range, channel, bounds);
+    return resolvePolarScaleRange(range, channel, bounds, polarFrame);
   }
   const validated = validateScaleRange(range);
   if (validated !== "auto") return validated;

package/src/grammar/scales/definition.js

@@ -1,4 +1,5 @@
-import { validateContinuousColorInterpolation } from "./color.js";
+import { validateMeasuredRadiusScale } from "./radial.js";
+import { validateContinuousColorInterpolation, validateSequentialMidpoint } from "./color.js";
 import { isTransformedScaleType } from "./mapping.js";
 import {
   normalizeTransformParameters,
@@ -23,13 +24,35 @@ function retainedValue(previous, patch, defaults, property, typeChanged) {
 }
 
 function validateBandParameters(definition, previous, patch, defaults, typeChanged) {
+  const hasPadding = Object.hasOwn(patch, "padding");
+  if (
+    hasPadding &&
+    (Object.hasOwn(patch, "paddingInner") || Object.hasOwn(patch, "paddingOuter"))
+  ) {
+    throw new Error(
+      "Scale padding cannot be combined with paddingInner or paddingOuter."
+    );
+  }
+  if (
+    hasPadding &&
+    (!Number.isFinite(patch.padding) || patch.padding < 0 || patch.padding >= 1)
+  ) {
+    throw new RangeError(
+      "Scale padding must be from 0 (inclusive) to 1 (exclusive)."
+    );
+  }
+  const normalizedPatch = hasPadding
+    ? { ...patch, paddingInner: patch.padding, paddingOuter: patch.padding }
+    : patch;
   const paddingInner = retainedValue(
-    previous, patch, defaults, "paddingInner", typeChanged
+    previous, normalizedPatch, defaults, "paddingInner", typeChanged
   ) ?? 0;
   const paddingOuter = retainedValue(
-    previous, patch, defaults, "paddingOuter", typeChanged
+    previous, normalizedPatch, defaults, "paddingOuter", typeChanged
   ) ?? 0;
-  const align = retainedValue(previous, patch, defaults, "align", typeChanged) ?? 0.5;
+  const align = retainedValue(
+    previous, normalizedPatch, defaults, "align", typeChanged
+  ) ?? 0.5;
   if (!Number.isFinite(paddingInner) || paddingInner < 0 || paddingInner >= 1) {
     throw new RangeError(
       "Scale paddingInner must be from 0 (inclusive) to 1 (exclusive)."
@@ -65,6 +88,7 @@ export function normalizeScaleDefinition({
   defaults = {},
   retainCoreOnTypeChange = false,
   retainCompatibleOnTypeChange = false,
+  allowOrdinalBandParameters = false,
   validateDomain,
   validateRange
 }) {
@@ -137,7 +161,12 @@ export function normalizeScaleDefinition({
     throw new Error(`Scale type "${type}" does not support interpolate.`);
   }
 
-  if (type === "band") {
+  const midpoint = validateSequentialMidpoint(
+    retainedValue(previous, patch, defaults, "midpoint", typeChanged), type, definition.domain
+  );
+  if (midpoint !== undefined) definition.midpoint = midpoint;
+
+  if (type === "band" || (type === "ordinal" && allowOrdinalBandParameters)) {
     validateBandParameters(definition, previous, patch, defaults, typeChanged);
   } else if (type === "point") {
     validatePointParameters(definition, previous, patch, defaults, typeChanged);
@@ -149,5 +178,13 @@ export function normalizeScaleDefinition({
     }
   }
 
+  const radialMapping = Object.hasOwn(patch, "radialMapping") ? patch.radialMapping : previous.radialMapping;
+  if (radialMapping !== undefined) {
+    definition.radialMapping = radialMapping;
+    validateMeasuredRadiusScale({ ...definition,
+      ...(Object.hasOwn(patch, "unknown") || Object.hasOwn(previous, "unknown")
+        ? { unknown: patch.unknown ?? previous.unknown } : {})
+    }, { allowAuto: true });
+  }
   return definition;
 }

package/src/grammar/scales/discretized.js

@@ -1,6 +1,7 @@
 import { cloneAndFreeze } from "../../core/immutable.js";
 import { validateGeneratedItemLimit } from "../../core/validation.js";
 import { interpolateNumber } from "../numeric.js";
+import { formatValue, validateValueFormat } from "../valueFormat.js";
 import { resolveColorRange, validateColorRange } from "./appearance.js";
 import { SCALE_ROLES, validateScaleTypeForRole } from "./types.js";
 
@@ -162,17 +163,22 @@ export function mapDiscretizedColors(values, scale) {
   }));
 }
 
-export function formatDiscretizedIntervals(thresholds) {
+export function formatDiscretizedIntervals(thresholds, format = "auto") {
   nondecreasing(thresholds, "Discretized color thresholds");
+  const resolvedFormat = validateValueFormat(format, "Legend label format");
   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) => {
+  let labels = resolvedFormat === "auto"
+    ? thresholds.map(value => Number.isInteger(value) ? String(value) : value.toFixed(1))
+    : thresholds.map(value => formatValue(value, {
+        format: resolvedFormat,
+        valueType: "quantitative",
+        label: "Legend label format"
+      }));
+  if (resolvedFormat === "auto" && thresholds.some((value, index) => {
     const rounded = Number(labels[index]);
     return value !== 0 && rounded === 0 ||
       index > 0 && value !== thresholds[index - 1] &&

package/src/grammar/scales/fields.js

@@ -81,9 +81,37 @@ function validTimestamp(value) {
   return Number.isFinite(value) && Number.isFinite(new Date(value).getTime());
 }
 
-export function normalizeTemporalValue(value, field = "value", index = 0) {
+export function validateTemporalUnit(unit) {
+  if (unit !== undefined && !["auto", "year", "timestamp"].includes(unit)) {
+    throw new Error(`Unsupported temporalUnit "${unit}"; use auto, year, or timestamp.`);
+  }
+  return unit;
+}
+
+export function resolveTemporalUnit(options, fieldType, previous) {
+  if (fieldType !== "temporal") {
+    if (Object.hasOwn(options, "temporalUnit")) {
+      throw new Error("temporalUnit requires a temporal fieldType.");
+    }
+    return undefined;
+  }
+  validateTemporalUnit(options.temporalUnit);
+  const sameBinding = ["field", "datum"].some(key =>
+    Object.hasOwn(options, key) && Object.hasOwn(previous ?? {}, key) &&
+    options[key] === previous[key]);
+  return options.temporalUnit ?? (sameBinding && previous?.fieldType === "temporal"
+    ? previous.temporalUnit : undefined);
+}
+
+export function normalizeTemporalValue(value, field = "value", index = 0, temporalUnit = "auto") {
+  validateTemporalUnit(temporalUnit);
   let timestamp;
-  if (typeof value === "number") {
+  if (temporalUnit === "year") {
+    const year = typeof value === "string" && /^\d{4}$/.test(value) ? Number(value) : value;
+    if (Number.isInteger(year) && year >= 0 && year <= 9999) timestamp = utcDate(year);
+  } else if (temporalUnit === "timestamp") {
+    if (typeof value === "number") timestamp = value;
+  } else if (typeof value === "number") {
     timestamp = Number.isInteger(value) && value >= 1000 && value <= 9999
       ? utcDate(value)
       : value;
@@ -99,21 +127,22 @@ export function normalizeTemporalValue(value, field = "value", index = 0) {
   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}.`
+      `(including a valid date or four-digit year) at row ${index}; temporalUnit is ${temporalUnit}.`
     );
   }
   return timestamp;
 }
 
-export function readTemporalField(rows, field) {
+export function readTemporalField(rows, field, temporalUnit) {
   validateField(field);
+  validateTemporalUnit(temporalUnit);
   return cloneAndFreeze(rows.map((row, index) => {
     if (!Object.hasOwn(row, field)) {
       throw new TypeError(
         `Field "${field}" must contain a temporal string or finite timestamp at row ${index}.`
       );
     }
-    return normalizeTemporalValue(row[field], field, index);
+    return normalizeTemporalValue(row[field], field, index, temporalUnit);
   }));
 }
 
@@ -129,10 +158,11 @@ export function readNominalField(rows, field) {
   }));
 }
 
-export function readScaleField(rows, field, fieldType, { allowUnknown = false } = {}) {
+export function readScaleField(rows, field, fieldType, { allowUnknown = false, temporalUnit } = {}) {
   validateSemanticFieldType(fieldType);
+  validateTemporalUnit(temporalUnit);
   if (!allowUnknown) {
-    if (fieldType === "temporal") return readTemporalField(rows, field);
+    if (fieldType === "temporal") return readTemporalField(rows, field, temporalUnit);
     if (["nominal", "ordinal"].includes(fieldType)) {
       return readNominalField(rows, field);
     }
@@ -149,7 +179,7 @@ export function readScaleField(rows, field, fieldType, { allowUnknown = false }
       return isNominalValue(value) ? value : undefined;
     }
     try {
-      return normalizeTemporalValue(value, field, index);
+      return normalizeTemporalValue(value, field, index, temporalUnit);
     } catch {
       return undefined;
     }

package/src/grammar/scales/index.js

@@ -7,6 +7,7 @@ export * from "./fields.js";
 export * from "./mapping.js";
 export * from "./ordinal.js";
 export * from "./policies.js";
+export * from "./size.js";
 export * from "./transformed.js";
 export * from "./types.js";
 export * from "./validation.js";

package/src/grammar/scales/mapping.js

@@ -1,3 +1,4 @@
+import { mapMeasuredRadiusValues } from "./radial.js";
 import { mapLinearValues } from "./continuous.js";
 import { mapTransformedValues } from "./transformed.js";
 import { SCALE_ROLES, validateScaleTypeForRole } from "./types.js";
@@ -9,6 +10,7 @@ export function isTransformedScaleType(type) {
 }
 
 export function mapContinuousScaleValues(values, scale) {
+  if (scale?.radialMapping !== undefined) return mapMeasuredRadiusValues(values, scale);
   if (isTransformedScaleType(scale?.type)) {
     validateScaleTypeForRole(scale.type, SCALE_ROLES.quantitativePosition);
     return mapTransformedValues(values, scale.domain, scale.range, {

package/src/grammar/scales/ordinal.js

@@ -196,6 +196,7 @@ export function resolveOrdinalOffsetScale({
   parentBandwidth,
   paddingInner = 0,
   paddingOuter = 0,
+  align = 0.5,
   channel = "xOffset"
 }) {
   const resolvedDomain = resolveOrdinalDomain(domain, values);
@@ -217,6 +218,9 @@ export function resolveOrdinalOffsetScale({
       "Offset scale paddingOuter must be a non-negative finite number."
     );
   }
+  if (!Number.isFinite(align) || align < 0 || align > 1) {
+    throw new RangeError("Offset scale align must be between 0 and 1.");
+  }
   validateDomainValues(resolvedDomain, values, undefined, "ordinal");
   const denominator = Math.max(
     1,
@@ -231,15 +235,18 @@ export function resolveOrdinalOffsetScale({
   if (!Number.isFinite(bandwidth) || bandwidth <= 0) {
     throw new Error("Offset scale padding must leave a positive bandwidth.");
   }
+  const occupied = step * (resolvedDomain.length - paddingInner);
+  const start = resolvedRange[0] + (resolvedRange[1] - resolvedRange[0] - occupied) * align;
   return cloneAndFreeze({
     type: "ordinal",
     domain: resolvedDomain,
     range: resolvedRange,
     step,
-    start: resolvedRange[0] + step * paddingOuter,
+    start,
     bandwidth,
     paddingInner,
-    paddingOuter
+    paddingOuter,
+    align
   });
 }
 
@@ -296,7 +303,9 @@ export function mapOrdinalOffsetValues(values, scale) {
     return finitePosition(
       direct,
       scale,
-      (scale.paddingOuter + index + (1 - scale.paddingInner) / 2) /
+      (scale.paddingOuter * 2 * scale.align +
+        index +
+        (1 - scale.paddingInner) / 2) /
         denominator
     );
   }));

package/src/grammar/scales/policies.js

@@ -9,9 +9,9 @@ export function validateScaleUnknown(channel, value) {
     }
     return value;
   }
-  if (channel === "color") {
+  if (["color", "stroke"].includes(channel)) {
     if (typeof value !== "string" || value.length === 0) {
-      throw new TypeError("Scale unknown for color must be a non-empty color string.");
+      throw new TypeError(`Scale unknown for ${channel} must be a non-empty color string.`);
     }
     return value;
   }