ggaction 0.0.9 → 0.0.11

package/src/grammar/lineSeries.js

@@ -8,11 +8,16 @@ import {
   aggregateRows,
   isAggregate,
   validateAggregateFieldType,
-  validateAggregateFieldValues,
+  validateAggregateFieldValues
 } from "./aggregate.js";
 import { stableOrderPathValues } from "./pathOrder.js";
+import { finiteMidpoint } from "./numeric.js";
+import {
+  findHistogramBinIndex,
+  resolveHistogramBins
+} from "./histogram.js";
 
-const SERIES_CHANNELS = Object.freeze(["group", "color", "strokeDash"]);
+const SERIES_CHANNELS = ["group", "color", "strokeDash"];
 
 function requireLineEncoding(layer) {
   if (layer?.mark?.type !== "line") {
@@ -26,10 +31,16 @@ function requireLineEncoding(layer) {
     throw new Error(`Line mark "${layer.id}" requires a temporal x encoding.`);
   }
 
+  const binnedAggregate =
+    x?.fieldType === "quantitative" &&
+    x.bin !== undefined &&
+    isAggregate(y?.aggregate);
   const aggregateMode =
-    x?.fieldType === "temporal" && isAggregate(y?.aggregate);
+    (x?.fieldType === "temporal" && isAggregate(y?.aggregate)) ||
+    binnedAggregate;
   const directQuantitative =
     x?.fieldType === "quantitative" &&
+    x.bin === undefined &&
     y?.fieldType === "quantitative" &&
     y.aggregate === undefined;
   const directTemporal =
@@ -53,6 +64,8 @@ function requireLineEncoding(layer) {
     x,
     y,
     isAggregate: aggregateMode,
+    binnedAggregate,
+    directRows: directTemporal || directQuantitative,
     directTemporal
   };
 }
@@ -87,8 +100,50 @@ function groupKey(values) {
   return JSON.stringify(values);
 }
 
-function deriveCartesianLineSeries(rows, layer) {
-  const { x, y, isAggregate, directTemporal } = requireLineEncoding(layer);
+function groupedSeries(groups, fields, dimensions) {
+  const id = groupKey(dimensions);
+  let series = groups.get(id);
+  if (series === undefined) {
+    series = {
+      key: Object.fromEntries(
+        fields.map((field, index) => [field, dimensions[index]])
+      ),
+      values: []
+    };
+    groups.set(id, series);
+  }
+  return series;
+}
+
+function freezeCartesianSeries(series) {
+  return cloneAndFreeze({
+    xValues: series.flatMap(item => item.values.map(value => value.x)),
+    yValues: series.flatMap(item => item.values.map(value => value.y)),
+    series
+  });
+}
+
+export function resolveLineBins(rows, layer, scale = {}) {
+  const x = layer?.encoding?.x;
+  if (
+    layer?.mark?.type !== "line" ||
+    x?.fieldType !== "quantitative" ||
+    x.bin === undefined
+  ) {
+    return undefined;
+  }
+  return resolveHistogramBins({
+    values: readQuantitativeField(rows, x.field),
+    bin: x.bin,
+    domain: scale.domain ?? "auto",
+    nice: scale.nice ?? true,
+    zero: scale.zero ?? false
+  });
+}
+
+function deriveCartesianLineSeries(rows, layer, options = {}) {
+  const { x, y, isAggregate, binnedAggregate, directRows, directTemporal } =
+    requireLineEncoding(layer);
   if (isAggregate) {
     validateAggregateFieldValues(rows, y.field, y.fieldType);
   }
@@ -101,6 +156,9 @@ function deriveCartesianLineSeries(rows, layer) {
       ? readTemporalField(rows, y.field)
       : readQuantitativeField(rows, y.field);
   const seriesFields = readSeriesFields(rows, layer);
+  const binBoundaries = binnedAggregate
+    ? options.xBinBoundaries ?? resolveLineBins(rows, layer).boundaries
+    : undefined;
 
   const pathOrder = layer.encoding?.pathOrder;
   if (pathOrder !== undefined) {
@@ -115,17 +173,10 @@ function deriveCartesianLineSeries(rows, layer) {
       const dimensions = seriesFields.fields.map(
         field => seriesFields.values.get(field)[index]
       );
-      const key = groupKey(dimensions);
-      const series = groups.get(key) ?? {
-        key: Object.fromEntries(
-          seriesFields.fields.map((field, item) => [field, dimensions[item]])
-        ),
-        values: [],
-        orderValues: []
-      };
+      const series = groupedSeries(groups, seriesFields.fields, dimensions);
       series.values.push({ x: xValues[index], y: yValues[index] });
+      series.orderValues ??= [];
       series.orderValues.push(orderValues[index]);
-      groups.set(key, series);
     }
     const series = [...groups.values()].flatMap(item => {
       const values = stableOrderPathValues(
@@ -140,30 +191,19 @@ function deriveCartesianLineSeries(rows, layer) {
         `Line series on mark "${layer.id}" requires at least two ordered points.`
       );
     }
-    return cloneAndFreeze({
-      xValues: series.flatMap(item => item.values.map(value => value.x)),
-      yValues: series.flatMap(item => item.values.map(value => value.y)),
-      series
-    });
+    return freezeCartesianSeries(series);
   }
 
-  if (directTemporal) {
+  if (directRows) {
     const groups = new Map();
     for (let index = 0; index < rows.length; index += 1) {
       const dimensions = seriesFields.fields.map(
         field => seriesFields.values.get(field)[index]
       );
-      const key = groupKey(dimensions);
-      const series = groups.get(key) ?? {
-        key: Object.fromEntries(
-          seriesFields.fields.map((field, item) => [field, dimensions[item]])
-        ),
-        values: []
-      };
+      const series = groupedSeries(groups, seriesFields.fields, dimensions);
       series.values.push({ x: xValues[index], y: yValues[index] });
-      groups.set(key, series);
     }
-    const orderBy = x.fieldType === "temporal" ? "x" : "y";
+    const orderBy = directTemporal && y.fieldType === "temporal" ? "y" : "x";
     const series = [...groups.values()].flatMap(item => {
       const values = item.values.sort(
         (left, right) => left[orderBy] - right[orderBy]
@@ -175,11 +215,7 @@ function deriveCartesianLineSeries(rows, layer) {
         `Line series on mark "${layer.id}" requires at least two direct points.`
       );
     }
-    return cloneAndFreeze({
-      xValues: series.flatMap(item => item.values.map(value => value.x)),
-      yValues: series.flatMap(item => item.values.map(value => value.y)),
-      series
-    });
+    return freezeCartesianSeries(series);
   }
   const aggregateGroups = new Map();
 
@@ -187,9 +223,19 @@ function deriveCartesianLineSeries(rows, layer) {
     const dimensions = seriesFields.fields.map(
       field => seriesFields.values.get(field)[index]
     );
-    const key = groupKey([xValues[index], ...dimensions]);
+    const binIndex = binnedAggregate
+      ? findHistogramBinIndex(xValues[index], binBoundaries)
+      : undefined;
+    if (binIndex === -1) continue;
+    const position = binnedAggregate
+      ? finiteMidpoint(
+          binBoundaries[binIndex],
+          binBoundaries[binIndex + 1]
+        )
+      : xValues[index];
+    const key = groupKey([binnedAggregate ? binIndex : position, ...dimensions]);
     const group = aggregateGroups.get(key) ?? {
-      x: xValues[index],
+      x: position,
       dimensions,
       rows: []
     };
@@ -205,23 +251,18 @@ function deriveCartesianLineSeries(rows, layer) {
   const seriesGroups = new Map();
 
   for (const group of aggregateGroups.values()) {
-    const value = isAggregate
-      ? aggregateRows(group.rows, y.field, y.aggregate)
-      : group.rows.reduce((sum, row) => sum + row[y.field], 0);
+    const value = aggregateRows(group.rows, y.field, y.aggregate);
     if (value === undefined) continue;
-    const key = groupKey(group.dimensions);
-    const series = seriesGroups.get(key) ?? {
-      key: Object.fromEntries(
-        seriesFields.fields.map((field, index) => [field, group.dimensions[index]])
-      ),
-      values: []
-    };
+    const series = groupedSeries(
+      seriesGroups,
+      seriesFields.fields,
+      group.dimensions
+    );
 
     series.values.push({
       x: group.x,
       y: value
     });
-    seriesGroups.set(key, series);
   }
 
   const series = [...seriesGroups.values()].flatMap(item => {
@@ -240,11 +281,7 @@ function deriveCartesianLineSeries(rows, layer) {
     );
   }
 
-  return cloneAndFreeze({
-    xValues: series.flatMap(item => item.values.map(value => value.x)),
-    yValues: series.flatMap(item => item.values.map(value => value.y)),
-    series
-  });
+  return freezeCartesianSeries(series);
 }
 
 function requirePolarLineEncoding(layer) {
@@ -311,20 +348,13 @@ export function derivePolarLineSeries(rows, layer, { thetaDomain } = {}) {
     const dimensions = seriesFields.fields.map(
       field => seriesFields.values.get(field)[index]
     );
-    const key = groupKey(dimensions);
-    const series = groups.get(key) ?? {
-      key: Object.fromEntries(
-        seriesFields.fields.map((field, item) => [field, dimensions[item]])
-      ),
-      values: []
-    };
+    const series = groupedSeries(groups, seriesFields.fields, dimensions);
     series.values.push({
       theta: thetaValues[index],
       radius: radiusValues[index],
       order: sortValues[index],
       sourceIndex: index
     });
-    groups.set(key, series);
   }
 
   const series = [...groups.values()].flatMap(item => {
@@ -352,7 +382,7 @@ export function deriveLineSeries(rows, layer, options) {
     layer?.encoding?.radius !== undefined;
   return polar
     ? derivePolarLineSeries(rows, layer, options)
-    : deriveCartesianLineSeries(rows, layer);
+    : deriveCartesianLineSeries(rows, layer, options);
 }
 
 export function deriveLineSeriesFieldValues(rows, layer, derived, field) {

package/src/grammar/numeric.js

@@ -0,0 +1,290 @@
+export const NICE_FACTORS = Object.freeze([1, 2, 3, 5]);
+
+function finiteArray(values, label) {
+  if (!Array.isArray(values) || !values.every(Number.isFinite)) {
+    throw new TypeError(`${label} must contain finite numbers.`);
+  }
+}
+
+function rangeError(label) {
+  return new RangeError(`${label} is outside the finite numeric range.`);
+}
+
+function compensatedSum(values, scale = 1) {
+  let total = 0;
+  let correction = 0;
+  for (const source of values) {
+    const value = source / scale;
+    const next = total + value;
+    correction += Math.abs(total) >= Math.abs(value)
+      ? total - next + value
+      : value - next + total;
+    total = next;
+  }
+  return total + correction;
+}
+
+export function maximumMagnitude(values) {
+  let maximum = 0;
+  for (const value of values) maximum = Math.max(maximum, Math.abs(value));
+  return maximum;
+}
+
+export function normalizedFiniteSum(values, label = "Numeric values") {
+  finiteArray(values, label);
+  const scale = maximumMagnitude(values) || 1;
+  return { scale, total: compensatedSum(values, scale) };
+}
+
+export function requireFiniteResult(value, label = "Numeric result") {
+  if (!Number.isFinite(value)) throw rangeError(label);
+  return value === 0 ? 0 : value;
+}
+
+export function restoreFiniteScale(value, scale, label = "Numeric result") {
+  if (!Number.isFinite(value) || !Number.isFinite(scale) || scale < 0) {
+    throw rangeError(label);
+  }
+  return requireFiniteResult(value * scale, label);
+}
+
+function stableReducedSum(values, label, divisor = 1) {
+  finiteArray(values, label);
+  const ordinary = values.reduce((sum, value) => sum + value, 0);
+  if (Number.isFinite(ordinary)) {
+    return ordinary === 0 ? 0 : ordinary / divisor;
+  }
+  const scale = maximumMagnitude(values) || 1;
+  return restoreFiniteScale(
+    compensatedSum(values, scale) / divisor, scale, label
+  );
+}
+
+export function stableFiniteSum(values, label = "Numeric sum") {
+  return stableReducedSum(values, label);
+}
+
+export function stableFinitePrefixSums(values, label = "Numeric sum") {
+  const normalized = normalizedFiniteSum(values, label);
+  let ordinary = 0;
+  let sum = 0;
+  let correction = 0;
+  return values.map(value => {
+    ordinary += value;
+    const scaled = value / normalized.scale;
+    const next = sum + scaled;
+    correction += Math.abs(sum) >= Math.abs(scaled)
+      ? sum - next + scaled
+      : scaled - next + sum;
+    sum = next;
+    return Number.isFinite(ordinary)
+      ? ordinary === 0 ? 0 : ordinary
+      : restoreFiniteScale(sum + correction, normalized.scale, label);
+  });
+}
+
+export function stableFiniteMean(values, label = "Numeric mean") {
+  finiteArray(values, label);
+  if (values.length === 0) {
+    throw new RangeError(`${label} requires at least one value.`);
+  }
+  return stableReducedSum(values, label, values.length);
+}
+
+export function stableFiniteSquareSum(values, label = "Numeric square sum") {
+  finiteArray(values, label);
+  const ordinary = values.reduce((sum, value) => sum + value ** 2, 0);
+  if (Number.isFinite(ordinary)) return ordinary;
+  const scale = maximumMagnitude(values);
+  if (scale === 0) return 0;
+  const normalized = values.reduce(
+    (sum, value) => sum + (value / scale) ** 2,
+    0
+  );
+  const magnitude = restoreFiniteScale(Math.sqrt(normalized), scale, label);
+  return requireFiniteResult(magnitude ** 2, label);
+}
+
+export function stableFiniteDeviation(values, {
+  sample = false,
+  divisor = 1,
+  label = "Numeric deviation"
+} = {}) {
+  if (!Number.isFinite(divisor) || divisor <= 0) {
+    throw new RangeError(`${label} divisor must be positive and finite.`);
+  }
+  const denominator = values.length - (sample ? 1 : 0);
+  if (denominator <= 0) {
+    throw new RangeError(`${label} requires more values.`);
+  }
+  const mean = stableFiniteMean(values, `${label} mean`);
+  const differences = values.map(value => value - mean);
+  const squared = differences.reduce(
+    (sum, difference) => sum + difference ** 2,
+    0
+  );
+  if (Number.isFinite(squared)) {
+    return {
+      mean,
+      deviation: Math.sqrt(squared / denominator) / divisor,
+      squared
+    };
+  }
+  const finiteDifferences = differences.every(Number.isFinite);
+  const scale = finiteDifferences
+    ? maximumMagnitude(differences)
+    : Math.max(Math.abs(mean), maximumMagnitude(values));
+  if (scale === 0) return { mean, deviation: 0 };
+  const normalizedSquares = values.reduce((sum, value, index) => {
+    const difference = finiteDifferences
+      ? differences[index] / scale
+      : value / scale - mean / scale;
+    return sum + difference ** 2;
+  }, 0);
+  const deviation = restoreFiniteScale(
+    Math.sqrt(normalizedSquares / denominator) / divisor,
+    scale,
+    label
+  );
+  return { mean, deviation };
+}
+
+export function numericExtent(values) {
+  let minimum = Infinity;
+  let maximum = -Infinity;
+  for (const value of values) {
+    minimum = Math.min(minimum, value);
+    maximum = Math.max(maximum, value);
+  }
+  return [minimum, maximum];
+}
+
+export function normalizeNumericRange(start, end) {
+  const magnitude = Math.max(Math.abs(start), Math.abs(end));
+  if (magnitude === 0) {
+    return { scale: 1, start: 0, end: 0, span: 0 };
+  }
+
+  const decimalScale = 10 ** Math.floor(Math.log10(magnitude));
+  const scale = Number.isFinite(decimalScale) && decimalScale > 0
+    ? decimalScale
+    : magnitude;
+  start /= scale;
+  end /= scale;
+  return {
+    scale,
+    start,
+    end,
+    span: end - start
+  };
+}
+
+export function niceNumericStep(
+  span,
+  count = 5,
+  factors = NICE_FACTORS
+) {
+  if (!Number.isFinite(span) || span <= 0) {
+    throw new RangeError("Nice numeric span must be positive and finite.");
+  }
+  const rough = span / Math.max(1, count);
+  const power = 10 ** Math.floor(Math.log10(rough));
+  const fraction = rough / power;
+  const factor = factors.find(candidate => candidate >= fraction) ?? 10;
+  return factor * power;
+}
+
+export function alignNumericStep(value, step, direction) {
+  let quotient = value / step;
+  const nearest = Math.round(quotient);
+  if (Math.abs(quotient - nearest) <= 1e-10) quotient = nearest;
+  return (direction === "floor" ? Math.floor(quotient) : Math.ceil(quotient)) * step;
+}
+
+export function cleanNumericValue(value, resolution) {
+  if (!Number.isFinite(value) || value === 0) return value === 0 ? 0 : value;
+  const rounded = Number(value.toPrecision(15));
+  return Number.isFinite(resolution) && resolution > 0 &&
+    Math.abs(rounded - value) <= resolution * 1e-10
+    ? rounded
+    : value;
+}
+
+export function inverseLerp(value, start, end) {
+  if (value === start) return 0;
+  if (value === end) return 1;
+
+  const span = end - start;
+  const offset = value - start;
+  if (Number.isFinite(span) && span !== 0 && Number.isFinite(offset)) {
+    return offset / span;
+  }
+
+  const scale = Math.max(Math.abs(value), Math.abs(start), Math.abs(end));
+  return (value / scale - start / scale) / (end / scale - start / scale);
+}
+
+export function interpolateNumber(start, end, proportion) {
+  let result = proportion === 0 ? start : proportion === 1 ? end : undefined;
+  if (result === undefined) {
+    const span = end - start;
+    if (Number.isFinite(span)) {
+      result = start + proportion * span;
+    } else {
+      const scale = Math.max(Math.abs(start), Math.abs(end));
+      result = scale * (
+        start / scale * (1 - proportion) + end / scale * proportion
+      );
+    }
+  }
+  return requireFiniteResult(result, "Numeric interpolation");
+}
+
+export function finiteMidpoint(start, end) {
+  const sum = start + end;
+  const result = Number.isFinite(sum) ? sum / 2 : start / 2 + end / 2;
+  return requireFiniteResult(result, "Numeric midpoint");
+}
+
+export function sampleNumericRange(start, end, count, label = "Numeric range") {
+  const resolution = Math.abs((end - start) / (count - 1));
+  const values = [];
+  const direction = Math.sign(end - start);
+  for (let index = 0; index < count; index += 1) {
+    const value = cleanNumericValue(
+      interpolateNumber(start, end, index / (count - 1)),
+      resolution
+    );
+    if (
+      !Number.isFinite(value) ||
+      (direction !== 0 && index > 0 &&
+        direction * (value - values[index - 1]) <= 0)
+    ) {
+      throw new RangeError(`${label} cannot represent ${count} distinct samples.`);
+    }
+    values.push(value);
+  }
+  return values;
+}
+
+export function formatDistinctNumericSamples(values, initialFormat) {
+  let labels = values.map(initialFormat ?? (value =>
+    String(+value.toPrecision(3))
+  ));
+  const distinct = () => labels.every((label, index) =>
+    index === 0 || values[index] === values[index - 1] ||
+    label !== labels[index - 1]
+  );
+  for (let precision = 4; !distinct() && precision <= 17; precision += 1) {
+    labels = values.map(value => String(+value.toPrecision(precision)));
+  }
+  return distinct() ? labels : values.map(String);
+}
+
+export function stableDecimal(value, places = 12) {
+  if (value === 0) return 0;
+  const threshold = 10 ** -places;
+  return Math.abs(value) < threshold
+    ? Number(value.toPrecision(places))
+    : Number(value.toFixed(places));
+}

package/src/grammar/paint.js

@@ -1,4 +1,5 @@
 import { isPlainObject } from "../core/immutable.js";
+import { interpolateNumber } from "./numeric.js";
 
 const PAINT_KEYS = Object.freeze(["type", "from", "to", "stops"]);
 const POINT_KEYS = Object.freeze(["x", "y"]);
@@ -78,11 +79,9 @@ export function resolveLinearGradientCoordinates(paint, bounds) {
   ) {
     throw new TypeError("Linear gradient bounds must be finite and ordered.");
   }
-  const width = bounds.right - bounds.left;
-  const height = bounds.bottom - bounds.top;
   const point = value => Object.freeze({
-    x: bounds.left + width * value.x,
-    y: bounds.top + height * value.y
+    x: interpolateNumber(bounds.left, bounds.right, value.x),
+    y: interpolateNumber(bounds.top, bounds.bottom, value.y)
   });
   return Object.freeze({ from: point(paint.from), to: point(paint.to) });
 }

package/src/grammar/palettes.js

@@ -1,9 +1,12 @@
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
-import { validateKeys } from "../core/validation.js";
+import {
+  validateGeneratedItemLimit,
+  validateKeys
+} from "../core/validation.js";
 
 function colors(encoded) {
   return cloneAndFreeze(
-    encoded.match(/.{6}/g).map(value => `#${value.toLowerCase()}`)
+    encoded.match(/.{6}/g).map(value => `#${value}`)
   );
 }
 
@@ -82,38 +85,21 @@ const CONTINUOUS = Object.freeze({
 });
 
 export const PALETTE_NAMES = cloneAndFreeze([
-  "accent",
-  "category10", "category20", "category20b", "category20c",
-  "observable10",
-  "dark2", "paired", "pastel1", "pastel2",
-  "set1", "set2", "set3",
-  "tableau10", "tableau20",
-  "blues", "tealblues", "teals", "greens", "browns",
-  "oranges", "reds", "purples", "warmgreys", "greys",
-  "viridis", "magma", "inferno", "plasma", "cividis", "turbo",
-  "bluegreen", "bluepurple",
-  "goldgreen", "goldorange", "goldred",
-  "greenblue", "orangered",
-  "purplebluegreen", "purpleblue", "purplered", "redpurple",
-  "yellowgreenblue", "yellowgreen", "yelloworangebrown", "yelloworangered",
-  "darkblue", "darkgold", "darkgreen", "darkmulti", "darkred",
-  "lightgreyred", "lightgreyteal", "lightmulti", "lightorange", "lighttealblue",
-  "blueorange", "brownbluegreen", "purplegreen", "pinkyellowgreen",
-  "purpleorange", "redblue", "redgrey",
-  "redyellowblue", "redyellowgreen", "spectral",
-  "rainbow", "sinebow"
+  ...Object.keys(DISCRETE),
+  ...Object.keys(CONTINUOUS)
 ]);
 
-const PALETTE_SET = new Set(PALETTE_NAMES);
-
 export function validatePaletteName(name) {
-  if (typeof name !== "string" || !PALETTE_SET.has(name)) {
+  if (
+    typeof name !== "string" ||
+    !Object.hasOwn(DISCRETE, name) && !Object.hasOwn(CONTINUOUS, name)
+  ) {
     throw new Error(`Unknown palette "${name}".`);
   }
   return name;
 }
 
-export function normalizePalette(value) {
+export function normalizePalette(value, maximum) {
   if (typeof value === "string") return { name: validatePaletteName(value) };
   if (!isPlainObject(value)) {
     throw new TypeError("Palette must be a name or a plain object.");
@@ -125,6 +111,7 @@ export function normalizePalette(value) {
     if (!Number.isInteger(value.count) || value.count <= 0) {
       throw new RangeError("Palette count must be a positive integer.");
     }
+    validateGeneratedItemLimit(value.count, "Palette count", maximum);
     normalized.count = value.count;
   }
   if (value.extent !== undefined) {
@@ -161,15 +148,14 @@ function interpolateColor(left, right, amount) {
 }
 
 function sample(colorsValue, position) {
-  const bounded = Math.max(0, Math.min(1, position));
-  const scaled = bounded * (colorsValue.length - 1);
+  const scaled = position * (colorsValue.length - 1);
   const left = Math.floor(scaled);
   const right = Math.min(colorsValue.length - 1, left + 1);
   return interpolateColor(colorsValue[left], colorsValue[right], scaled - left);
 }
 
-export function resolvePalette(value, domainCount) {
-  const palette = normalizePalette(value);
+export function resolvePalette(value, domainCount, maximum) {
+  const palette = normalizePalette(value, maximum);
   const discrete = DISCRETE[palette.name];
   if (discrete !== undefined) {
     const count = palette.count ?? discrete.length;
@@ -182,6 +168,7 @@ export function resolvePalette(value, domainCount) {
   }
   const source = CONTINUOUS[palette.name];
   const count = palette.count ?? domainCount;
+  validateGeneratedItemLimit(count, "Palette count", maximum);
   const extent = palette.extent ?? [0, 1];
   return cloneAndFreeze(Array.from({ length: count }, (_, index) => {
     const unit = count === 1 ? 0.5 : index / (count - 1);
@@ -195,12 +182,14 @@ export function resolveContinuousPalette(value, count = 31) {
   if (!Number.isInteger(resolvedCount) || resolvedCount < 2) {
     throw new RangeError("Continuous palette count must be an integer of at least 2.");
   }
+  validateGeneratedItemLimit(resolvedCount, "Continuous palette count");
   const discrete = DISCRETE[palette.name];
   if (discrete !== undefined && palette.count === undefined) return discrete;
   return resolvePalette({ ...palette, count: resolvedCount }, resolvedCount);
 }
 
 export function paletteFamily(name) {
-  const validated = validatePaletteName(name);
-  return DISCRETE[validated] === undefined ? "continuous" : "categorical";
+  return DISCRETE[validatePaletteName(name)] === undefined
+    ? "continuous"
+    : "categorical";
 }