ggaction 0.0.1

package/src/grammar/scales/ordinal.js

@@ -0,0 +1,221 @@
+import { cloneAndFreeze } from "../../core/immutable.js";
+import { isNominalValue } from "./fields.js";
+import { validateColorRange, validateStrokeDashRange } from "./appearance.js";
+import { validatePair, validateScaleRange } from "./validation.js";
+import { resolveScaleRange } from "./continuous.js";
+
+export function validateOrdinalDomain(domain) {
+  if (domain === "auto") return domain;
+  if (
+    !Array.isArray(domain) ||
+    domain.length === 0 ||
+    !domain.every(isNominalValue) ||
+    new Set(domain).size !== domain.length
+  ) {
+    throw new TypeError(
+      "Ordinal domain must be \"auto\" or unique nominal values."
+    );
+  }
+  return cloneAndFreeze(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);
+  }
+  return validateColorRange(range);
+}
+
+export function resolveOrdinalDomain(domain, values) {
+  const validated = validateOrdinalDomain(domain);
+  if (validated !== "auto") return validated;
+  if (values.length === 0) {
+    throw new Error("Cannot infer an automatic ordinal domain from no values.");
+  }
+  return cloneAndFreeze([...new Set(values)]);
+}
+
+export function resolveOrdinalPositionScale({
+  domain,
+  values,
+  range,
+  channel,
+  bounds,
+  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({
+    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;
+}
+
+export function resolveDiscretePositionScale({
+  type,
+  domain,
+  values,
+  range,
+  channel,
+  bounds,
+  paddingInner = 0,
+  paddingOuter = 0,
+  padding = 0.5,
+  align = 0.5,
+  unknown
+}) {
+  if (!["band", "point"].includes(type)) {
+    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.`);
+    }
+  }
+  validateAlign(align);
+  if (type === "band") {
+    if (!Number.isFinite(paddingInner) || paddingInner < 0 || paddingInner >= 1) {
+      throw new RangeError(
+        "Band scale paddingInner must be from 0 (inclusive) to 1 (exclusive)."
+      );
+    }
+    if (!Number.isFinite(paddingOuter) || paddingOuter < 0) {
+      throw new RangeError(
+        "Band scale paddingOuter must be a non-negative finite number."
+      );
+    }
+  } else if (!Number.isFinite(padding) || padding < 0) {
+    throw new RangeError(
+      "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"
+    ? Math.max(1, count - paddingInner + paddingOuter * 2)
+    : Math.max(1, count - 1 + padding * 2);
+  const step = direction * span / denominator;
+  const bandwidth = type === "band"
+    ? Math.abs(step) * (1 - paddingInner)
+    : 0;
+  const outerPadding = type === "band" ? paddingOuter : padding;
+  const start = resolvedRange[0] +
+    direction * Math.abs(step) * outerPadding * 2 * align;
+  return cloneAndFreeze({
+    type,
+    domain: resolvedDomain,
+    range: resolvedRange,
+    step,
+    start,
+    bandwidth,
+    align,
+    ...(type === "band" ? { paddingInner, paddingOuter } : { padding })
+  });
+}
+
+export function resolveOrdinalOffsetScale({
+  domain,
+  values,
+  range,
+  parentBandwidth,
+  paddingInner = 0,
+  paddingOuter = 0
+}) {
+  const resolvedDomain = resolveOrdinalDomain(domain, values);
+  if (!Number.isFinite(parentBandwidth) || parentBandwidth <= 0) {
+    throw new Error("Automatic xOffset range requires a positive x bandwidth.");
+  }
+  const resolvedRange = range === "auto"
+    ? validatePair([0, parentBandwidth], "Offset scale range")
+    : validateScaleRange(range);
+  if (!Number.isFinite(paddingInner) || paddingInner < 0 || paddingInner >= 1) {
+    throw new RangeError(
+      "Offset scale paddingInner must be from 0 (inclusive) to 1 (exclusive)."
+    );
+  }
+  if (!Number.isFinite(paddingOuter) || paddingOuter < 0) {
+    throw new RangeError(
+      "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);
+  const bandwidth = Math.abs(step) * (1 - paddingInner);
+  if (!Number.isFinite(bandwidth) || bandwidth <= 0) {
+    throw new Error("Offset scale padding must leave a positive bandwidth.");
+  }
+  return cloneAndFreeze({
+    type: "ordinal",
+    domain: resolvedDomain,
+    range: resolvedRange,
+    step,
+    start: resolvedRange[0] + step * paddingOuter,
+    bandwidth,
+    paddingInner,
+    paddingOuter
+  });
+}
+
+export function mapOrdinalPositionValues(values, scale) {
+  const hasUnknown = Object.hasOwn(scale, "unknown");
+  const indices = new Map(scale.domain.map((value, index) => [value, index]));
+  return cloneAndFreeze(values.map(value => {
+    const index = indices.get(value);
+    if (index === undefined) {
+      if (hasUnknown) return scale.unknown;
+      throw new Error(`Value "${value}" is outside the ordinal domain.`);
+    }
+    if (
+      (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;
+    }
+    return scale.range[0] + (index + 0.5) * scale.step;
+  }));
+}

package/src/grammar/scales/policies.js

@@ -0,0 +1,50 @@
+import { cloneAndFreeze } from "../../core/immutable.js";
+import { POINT_SHAPES } from "../pointShapes.js";
+import { normalizeStrokeDashPattern } from "./appearance.js";
+
+export function validateScaleUnknown(channel, value) {
+  if (["x", "y", "xOffset"].includes(channel)) {
+    if (!Number.isFinite(value)) {
+      throw new TypeError(`Scale unknown for ${channel} must be a finite number.`);
+    }
+    return value;
+  }
+  if (channel === "color") {
+    if (typeof value !== "string" || value.length === 0) {
+      throw new TypeError("Scale unknown for color must be a non-empty color string.");
+    }
+    return value;
+  }
+  if (channel === "size") {
+    if (!Number.isFinite(value) || value < 0) {
+      throw new RangeError(
+        "Scale unknown for size must be a non-negative finite area."
+      );
+    }
+    return value;
+  }
+  if (channel === "opacity") {
+    if (!Number.isFinite(value) || value < 0 || value > 1) {
+      throw new RangeError("Scale unknown for opacity must be between 0 and 1.");
+    }
+    return value;
+  }
+  if (channel === "shape") {
+    if (!POINT_SHAPES.includes(value)) {
+      throw new Error(`Unsupported scale unknown shape "${value}".`);
+    }
+    return value;
+  }
+  if (channel === "strokeDash") {
+    return cloneAndFreeze(normalizeStrokeDashPattern(value));
+  }
+  throw new Error(`Scale unknown is not supported for channel "${channel}".`);
+}
+
+export function withScaleUnknown(target, source, channel) {
+  if (!Object.hasOwn(source, "unknown")) return target;
+  return {
+    ...target,
+    unknown: validateScaleUnknown(channel, source.unknown)
+  };
+}

package/src/grammar/scales/temporal.js

@@ -0,0 +1,53 @@
+import { cloneAndFreeze } from "../../core/immutable.js";
+
+const TIME_UNITS = [
+  { span: 2 * 365 * 24 * 60 * 60 * 1000, unit: "year" },
+  { span: 60 * 24 * 60 * 60 * 1000, unit: "month" },
+  { span: 2 * 24 * 60 * 60 * 1000, unit: "day" },
+  { span: 2 * 60 * 60 * 1000, unit: "hour" },
+  { span: 2 * 60 * 1000, unit: "minute" },
+  { span: 0, unit: "second" }
+];
+
+function floorUtc(timestamp, unit) {
+  const date = new Date(timestamp);
+  if (unit === "year") return Date.UTC(date.getUTCFullYear(), 0, 1);
+  if (unit === "month") return Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), 1);
+  if (unit === "day") {
+    return Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
+  }
+  if (unit === "hour") {
+    return Date.UTC(
+      date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), date.getUTCHours()
+    );
+  }
+  if (unit === "minute") {
+    return Date.UTC(
+      date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(),
+      date.getUTCHours(), date.getUTCMinutes()
+    );
+  }
+  return Math.floor(timestamp / 1000) * 1000;
+}
+
+function offsetUtc(timestamp, unit) {
+  const date = new Date(timestamp);
+  if (unit === "year") return Date.UTC(date.getUTCFullYear() + 1, 0, 1);
+  if (unit === "month") {
+    return Date.UTC(date.getUTCFullYear(), date.getUTCMonth() + 1, 1);
+  }
+  if (unit === "day") return timestamp + 24 * 60 * 60 * 1000;
+  if (unit === "hour") return timestamp + 60 * 60 * 1000;
+  if (unit === "minute") return timestamp + 60 * 1000;
+  return timestamp + 1000;
+}
+
+export function niceTimeDomain(domain) {
+  const [minimum, maximum] = domain;
+  if (minimum === maximum) return domain;
+  const unit = TIME_UNITS.find(item => maximum - minimum >= item.span).unit;
+  const start = floorUtc(minimum, unit);
+  const endFloor = floorUtc(maximum, unit);
+  const end = endFloor === maximum ? maximum : offsetUtc(endFloor, unit);
+  return cloneAndFreeze([start, end]);
+}

package/src/grammar/scales/transformed.js

@@ -0,0 +1,236 @@
+import { cloneAndFreeze, isPlainObject } from "../../core/immutable.js";
+import { niceTicks } from "../ticks.js";
+import { niceLinearDomain } from "./continuous.js";
+import {
+  SCALE_ROLES,
+  validateScaleTypeForRole
+} from "./types.js";
+import { validatePair } from "./validation.js";
+const TRANSFORMED_TYPES = Object.freeze(["log", "pow", "sqrt", "symlog"]);
+
+function positiveFinite(value, label) {
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new RangeError(`${label} must be a positive finite number.`);
+  }
+  return value;
+}
+
+export function normalizeTransformParameters(type, options = {}) {
+  if (!TRANSFORMED_TYPES.includes(type) && type !== "linear") {
+    throw new Error(`Scale type "${type}" is not a quantitative transform.`);
+  }
+  if (!isPlainObject(options)) {
+    throw new TypeError("Scale transform options must be a plain object.");
+  }
+  const allowed = type === "log"
+    ? ["base"]
+    : type === "pow"
+      ? ["exponent"]
+      : type === "symlog" ? ["constant"] : [];
+  for (const key of Object.keys(options)) {
+    if (!allowed.includes(key)) {
+      throw new Error(`Scale type "${type}" does not support ${key}.`);
+    }
+  }
+  if (type === "log") {
+    const base = positiveFinite(options.base ?? 10, "Log scale base");
+    if (base === 1) throw new RangeError("Log scale base must not equal 1.");
+    return cloneAndFreeze({ base });
+  }
+  if (type === "pow") {
+    return cloneAndFreeze({
+      exponent: positiveFinite(options.exponent ?? 1, "Power scale exponent")
+    });
+  }
+  if (type === "sqrt") return cloneAndFreeze({ exponent: 0.5 });
+  if (type === "symlog") {
+    return cloneAndFreeze({
+      constant: positiveFinite(options.constant ?? 1, "Symlog scale constant")
+    });
+  }
+  return cloneAndFreeze({});
+}
+
+function transformValue(value, type, parameters) {
+  if (type === "linear") return value;
+  if (type === "log") {
+    return Math.sign(value) * Math.log10(Math.abs(value)) /
+      Math.log10(parameters.base);
+  }
+  if (type === "sqrt") {
+    return Math.sign(value) * Math.sqrt(Math.abs(value));
+  }
+  const exponent = type === "sqrt" ? 0.5 : parameters.exponent;
+  if (type === "pow" || type === "sqrt") {
+    return Math.sign(value) * Math.abs(value) ** exponent;
+  }
+  return Math.sign(value) * Math.log1p(
+    Math.abs(value) / parameters.constant
+  );
+}
+
+export function validateTransformedDomain(type, domain, options = {}) {
+  validateScaleTypeForRole(type, SCALE_ROLES.quantitativePosition);
+  const validated = validatePair(domain, "Transformed scale domain");
+  if (validated[0] === validated[1]) {
+    throw new RangeError("Transformed scale domain values must be distinct.");
+  }
+  if (
+    type === "log" &&
+    (validated.includes(0) || Math.sign(validated[0]) !== Math.sign(validated[1]))
+  ) {
+    throw new RangeError(
+      "Log scale domain must be strictly positive or strictly negative."
+    );
+  }
+  normalizeTransformParameters(type, options);
+  return validated;
+}
+
+function niceLogDomain(domain, base) {
+  const reversed = domain[0] > domain[1];
+  const low = Math.min(...domain);
+  const high = Math.max(...domain);
+  let result;
+  if (low > 0) {
+    result = [
+      base ** Math.floor(Math.log(low) / Math.log(base)),
+      base ** Math.ceil(Math.log(high) / Math.log(base))
+    ];
+  } else {
+    result = [
+      -(base ** Math.ceil(Math.log(Math.abs(low)) / Math.log(base))),
+      -(base ** Math.floor(Math.log(Math.abs(high)) / Math.log(base)))
+    ];
+  }
+  return cloneAndFreeze(reversed ? result.reverse() : result);
+}
+
+export function resolveTransformedDomain({
+  type,
+  domain = "auto",
+  values,
+  nice = false,
+  zero = false,
+  ...options
+}) {
+  validateScaleTypeForRole(type, SCALE_ROLES.quantitativePosition);
+  if (!Array.isArray(values) || !values.every(Number.isFinite)) {
+    throw new TypeError("Transformed scale values must be finite numbers.");
+  }
+  if (typeof nice !== "boolean" || typeof zero !== "boolean") {
+    throw new TypeError("Scale nice and zero must be booleans.");
+  }
+  if (type === "log" && zero) {
+    throw new Error('Scale type "log" does not support zero.');
+  }
+  const explicit = domain !== "auto";
+  if (explicit) return validateTransformedDomain(type, domain, options);
+  if (values.length === 0) {
+    throw new Error("Cannot infer an automatic scale domain from no values.");
+  }
+  let resolved = [Math.min(...values), Math.max(...values)];
+  if (resolved[0] === resolved[1]) {
+    throw new RangeError("Automatic transformed domain requires distinct values.");
+  }
+  if (zero) resolved = [Math.min(0, resolved[0]), Math.max(0, resolved[1])];
+  validateTransformedDomain(type, resolved, options);
+  if (nice) {
+    resolved = type === "log"
+      ? niceLogDomain(resolved, normalizeTransformParameters(type, options).base)
+      : niceLinearDomain(resolved);
+  }
+  return validateTransformedDomain(type, resolved, options);
+}
+
+export function resolveMappingRange(range, { reverse = false } = {}) {
+  const validated = validatePair(range, "Scale range");
+  if (typeof reverse !== "boolean") {
+    throw new TypeError("Scale reverse must be a boolean.");
+  }
+  return reverse
+    ? cloneAndFreeze([...validated].reverse())
+    : validated;
+}
+
+export function mapTransformedValues(
+  values,
+  domain,
+  range,
+  { type = "linear", clamp = false, reverse = false, ...options } = {}
+) {
+  if (!Array.isArray(values)) {
+    throw new TypeError("Scale values must be an array.");
+  }
+  if (typeof clamp !== "boolean") {
+    throw new TypeError("Scale clamp must be a boolean.");
+  }
+  const hasUnknown = Object.hasOwn(options, "unknown");
+  const transformOptions = Object.fromEntries(
+    Object.entries(options).filter(([key]) => key !== "unknown")
+  );
+  const parameters = normalizeTransformParameters(type, transformOptions);
+  const domainOptions = type === "sqrt" ? {} : transformOptions;
+  const validatedDomain = validateTransformedDomain(type, domain, domainOptions);
+  const resolvedRange = resolveMappingRange(range, { reverse });
+  const transformedDomain = validatedDomain.map(value =>
+    transformValue(value, type, parameters)
+  );
+  const span = transformedDomain[1] - transformedDomain[0];
+
+  return cloneAndFreeze(values.map(value => {
+    const valid = Number.isFinite(value) && !(type === "log" && (
+      value === 0 || Math.sign(value) !== Math.sign(validatedDomain[0])
+    ));
+    if (!valid) {
+      if (hasUnknown) return options.unknown;
+      throw new TypeError(`Scale type "${type}" received an invalid value.`);
+    }
+    const transformed = transformValue(value, type, parameters);
+    let proportion = (transformed - transformedDomain[0]) / span;
+    if (clamp) proportion = Math.max(0, Math.min(1, proportion));
+    return resolvedRange[0] + proportion * (resolvedRange[1] - resolvedRange[0]);
+  }));
+}
+
+export function transformedTicks(type, domain, count, options = {}) {
+  const validated = validateTransformedDomain(type, domain, options);
+  if (!Number.isInteger(count) || count <= 0) {
+    throw new RangeError("Tick count must be a positive integer.");
+  }
+  if (type !== "log") return niceTicks(validated, count);
+  const { base } = normalizeTransformParameters(type, options);
+  const reversed = validated[0] > validated[1];
+  const low = Math.min(...validated);
+  const high = Math.max(...validated);
+  const negative = high < 0;
+  const minimumMagnitude = negative ? Math.abs(high) : low;
+  const maximumMagnitude = negative ? Math.abs(low) : high;
+  const start = Math.ceil(
+    Math.log(minimumMagnitude) / Math.log(base) - 1e-12
+  );
+  const end = Math.floor(
+    Math.log(maximumMagnitude) / Math.log(base) + 1e-12
+  );
+  const values = [];
+  for (let exponent = start; exponent <= end; exponent += 1) {
+    values.push((negative ? -1 : 1) * base ** exponent);
+  }
+  if (negative) values.reverse();
+  if (reversed) values.reverse();
+  return cloneAndFreeze(values.length === 0 ? [...validated] : values);
+}
+
+export function formatTransformedTick(type, value) {
+  if (type !== "log") return String(value);
+  const magnitude = Math.abs(value);
+  const units = [
+    [1_000_000_000, "B"],
+    [1_000_000, "M"],
+    [1_000, "K"]
+  ];
+  const unit = units.find(([threshold]) => magnitude >= threshold);
+  if (unit === undefined) return String(value);
+  const scaled = value / unit[0];
+  return `${Number(scaled.toPrecision(3))}${unit[1]}`;
+}

package/src/grammar/scales/types.js

@@ -0,0 +1,102 @@
+export const SCALE_ROLES = Object.freeze({
+  quantitativePosition: "quantitative-position",
+  temporalPosition: "temporal-position",
+  bandPosition: "band-position",
+  pointPosition: "point-position",
+  discreteAppearance: "discrete-appearance",
+  continuousColor: "continuous-color",
+  discretizedColor: "discretized-color"
+});
+
+export const SCALE_TYPES_BY_ROLE = Object.freeze({
+  [SCALE_ROLES.quantitativePosition]: Object.freeze([
+    "linear", "log", "pow", "sqrt", "symlog"
+  ]),
+  [SCALE_ROLES.temporalPosition]: Object.freeze(["time"]),
+  [SCALE_ROLES.bandPosition]: Object.freeze(["band"]),
+  [SCALE_ROLES.pointPosition]: Object.freeze(["point"]),
+  [SCALE_ROLES.discreteAppearance]: Object.freeze(["ordinal"]),
+  [SCALE_ROLES.continuousColor]: Object.freeze(["sequential"]),
+  [SCALE_ROLES.discretizedColor]: Object.freeze([
+    "quantize", "quantile", "threshold"
+  ])
+});
+
+export const COMPLETE_SCALE_TYPES = Object.freeze([
+  ...new Set(Object.values(SCALE_TYPES_BY_ROLE).flat())
+]);
+
+const SCALE_PROPERTY_TYPES = Object.freeze({
+  nice: Object.freeze(["linear", "log", "pow", "sqrt", "symlog", "time"]),
+  zero: Object.freeze(["linear", "pow", "sqrt", "symlog"]),
+  clamp: Object.freeze([
+    "linear", "log", "pow", "sqrt", "symlog", "time", "sequential",
+    "quantize"
+  ]),
+  base: Object.freeze(["log"]),
+  exponent: Object.freeze(["pow"]),
+  constant: Object.freeze(["symlog"]),
+  paddingInner: Object.freeze(["band"]),
+  paddingOuter: Object.freeze(["band"]),
+  padding: Object.freeze(["point"]),
+  align: Object.freeze(["band", "point"])
+});
+
+export function validateCompleteScaleType(type) {
+  if (!COMPLETE_SCALE_TYPES.includes(type)) {
+    throw new Error(`Unsupported scale type "${type}".`);
+  }
+  return type;
+}
+
+export function isDiscretePositionScaleType(type) {
+  return type === "band" || type === "point";
+}
+
+export function isContinuousPositionScaleType(type) {
+  return (
+    SCALE_TYPES_BY_ROLE[SCALE_ROLES.quantitativePosition].includes(type) ||
+    SCALE_TYPES_BY_ROLE[SCALE_ROLES.temporalPosition].includes(type)
+  );
+}
+
+export function isOrdinalScaleType(type) {
+  return type === "ordinal";
+}
+
+export function hasOrdinalDomain(type) {
+  return isOrdinalScaleType(type) || isDiscretePositionScaleType(type);
+}
+
+export function isContinuousColorScaleType(type) {
+  return SCALE_TYPES_BY_ROLE[SCALE_ROLES.continuousColor].includes(type);
+}
+
+export function isDiscretizedColorScaleType(type) {
+  return SCALE_TYPES_BY_ROLE[SCALE_ROLES.discretizedColor].includes(type);
+}
+
+export function isColorScaleType(type) {
+  return isContinuousColorScaleType(type) || isDiscretizedColorScaleType(type);
+}
+
+export function validateScaleTypeForRole(type, role) {
+  const accepted = SCALE_TYPES_BY_ROLE[role];
+  if (accepted === undefined) {
+    throw new Error(`Unknown scale role "${role}".`);
+  }
+  if (!accepted.includes(type)) {
+    throw new Error(`Scale type "${type}" is not valid for ${role}.`);
+  }
+  return type;
+}
+
+export function validateScalePropertyForType(type, property) {
+  validateCompleteScaleType(type);
+  const accepted = SCALE_PROPERTY_TYPES[property];
+  if (accepted === undefined) return property;
+  if (!accepted.includes(type)) {
+    throw new Error(`Scale type "${type}" does not support ${property}.`);
+  }
+  return property;
+}