per-channel scale override

Author: mbostock

src/channel.js

@@ -1,32 +1,44 @@
 import {ascending, descending, rollup, sort} from "d3";
-import {first, isIterable, labelof, map, maybeValue, range, valueof} from "./options.js";
+import {first, isColor, isFirst, isEvery, isIterable, labelof, map, maybeValue, range, valueof} from "./options.js";
 import {registry} from "./scales/index.js";
+import {isSymbol, maybeSymbol} from "./symbols.js";
 import {maybeReduce} from "./transforms/group.js";
 
 // TODO Type coercion?
-export function Channel(data, {scale, type, value, filter, hint}) {
+export function Channel(data, {scale, scaleLock, type, value, filter, hint}) {
+  let V = valueof(data, value);
+
+  // For color and symbol scales, if a scale is not explicitly specified when
+  // the channel is declared, ignore the channel’s default scale if the channel
+  // values are literal. In the case of symbols, we must further promote symbol
+  // names (e.g., "plus") to a symbol instance (symbolPlus). TODO Instead of a
+  // scaleLock property, use an "auto" scale?
+  const is = scaleLock || !V ? null : scale === "color" ? isColor : scale === "symbol" ? isSymbol : null;
+  if (is && isFirst(V, is) && isEvery(V, is)) {
+    if (is === isSymbol) V = map(V, maybeSymbol);
+    scale = undefined;
+  }
+
   return {
     scale,
     type,
-    value: valueof(data, value),
+    value: V,
     label: labelof(value),
     filter,
     hint
   };
 }
 
-export function Channels(descriptors, data) {
-  return Object.fromEntries(Object.entries(descriptors).map(([name, channel]) => [name, Channel(data, channel)]));
+export function Channels(channels, data) {
+  return Object.fromEntries(Object.entries(channels).map(([name, channel]) => [name, Channel(data, channel)]));
 }
 
 // TODO Use Float64Array for scales with numeric ranges, e.g. position?
 export function valueObject(channels, scales) {
   return Object.fromEntries(
     Object.entries(channels).map(([name, {scale: scaleName, value}]) => {
       let scale;
-      if (scaleName !== undefined) {
-        scale = scales[scaleName];
-      }
+      if (scaleName != null) scale = scales[scaleName];
       return [name, scale === undefined ? value : map(value, scale)];
     })
   );

src/mark.js

@@ -1,7 +1,7 @@
 import {Channels, channelDomain, valueObject} from "./channel.js";
 import {defined} from "./defined.js";
 import {maybeFacetAnchor} from "./facet.js";
-import {arrayify, isDomainSort, range} from "./options.js";
+import {arrayify, isDomainSort, isOptions, range} from "./options.js";
 import {keyword, maybeNamed} from "./options.js";
 import {maybeProject} from "./projection.js";
 import {maybeClip, styles} from "./style.js";
@@ -41,11 +41,24 @@ export class Mark {
     if (extraChannels !== undefined) channels = {...maybeNamed(extraChannels), ...channels};
     if (defaults !== undefined) channels = {...styles(this, options, defaults), ...channels};
     this.channels = Object.fromEntries(
-      Object.entries(channels).filter(([name, {value, optional}]) => {
-        if (value != null) return true;
-        if (optional) return false;
-        throw new Error(`missing channel value: ${name}`);
-      })
+      Object.entries(channels)
+        .map(([name, channel]) => {
+          let {value} = channel;
+          if (isOptions(value)) {
+            channel = {...channel};
+            if (value.scale !== undefined) {
+              channel.scale = value.scale;
+              channel.scaleLock = true;
+            }
+            channel.value = value.value;
+          }
+          return [name, channel];
+        })
+        .filter(([name, {value, optional}]) => {
+          if (value != null) return true;
+          if (optional) return false;
+          throw new Error(`missing channel value: ${name}`);
+        })
     );
     this.dx = +dx;
     this.dy = +dy;

src/scales.js

@@ -1,9 +1,6 @@
 import {parse as isoParse} from "isoformat";
 import {
-  isColor,
-  isEvery,
   isOrdinal,
-  isFirst,
   isTemporal,
   isTemporalString,
   isNumericString,
@@ -34,7 +31,7 @@ import {
 import {isDivergingScheme} from "./scales/schemes.js";
 import {ScaleTime, ScaleUtc} from "./scales/temporal.js";
 import {ScaleOrdinal, ScalePoint, ScaleBand, ordinalImplicit} from "./scales/ordinal.js";
-import {isSymbol, maybeSymbol} from "./symbols.js";
+import {maybeSymbol} from "./symbols.js";
 import {warn} from "./warnings.js";
 
 export function Scales(
@@ -406,20 +403,8 @@ function inferScaleType(key, channels, {type, domain, range, scheme, pivot, proj
   // If there’s no data (and no type) associated with this scale, don’t create a scale.
   if (domain === undefined && !channels.some(({value}) => value !== undefined)) return;
 
-  const kind = registry.get(key);
-
-  // For color scales, if no range or scheme is specified and all associated
-  // defined values (from the domain if present, and otherwise from channels)
-  // are valid colors, then default to the identity scale. This allows, for
-  // example, a fill channel to return literal colors; without this, the colors
-  // would be remapped to a categorical scheme!
-  if (kind === color && range === undefined && scheme === undefined && isAll(domain, channels, isColor))
-    return "identity";
-
-  // Similarly for symbols…
-  if (kind === symbol && range === undefined && isAll(domain, channels, isSymbol)) return "identity";
-
   // Some scales have default types.
+  const kind = registry.get(key);
   if (kind === radius) return "sqrt";
   if (kind === opacity || kind === length) return "linear";
   if (kind === symbol) return "ordinal";
@@ -461,13 +446,6 @@ function asOrdinalType(kind) {
   }
 }
 
-function isAll(domain, channels, is) {
-  return domain !== undefined
-    ? isFirst(domain, is) && isEvery(domain, is)
-    : channels.some(({value}) => value !== undefined && isFirst(value, is)) &&
-        channels.every(({value}) => value === undefined || isEvery(value, is));
-}
-
 export function isTemporalScale({type}) {
   return type === "time" || type === "utc";
 }