ggaction 0.0.10 → 0.0.12

package/src/grammar/facets/index.js

@@ -1,5 +1,9 @@
 import { cloneAndFreeze, isPlainObject } from "../../core/immutable.js";
 import { validateUserId } from "../../core/identifiers.js";
+import {
+  validateGeneratedItemLimit,
+  validateWorkLimit
+} from "../../core/validation.js";
 import { BAR_GRAINS, resolveBarGrain } from "../bars/policy.js";
 import { planFacetDependencies } from "./dependencies.js";
 import { readNominalField } from "../scales/index.js";
@@ -12,6 +16,7 @@ const SUPPORTED_BAR_GRAINS = new Set([
   BAR_GRAINS.aggregate,
   BAR_GRAINS.ranged
 ]);
+const MAX_FACET_CHILDREN = 100;
 
 function requireFacetField(field) {
   if (typeof field !== "string" || field.length === 0) {
@@ -109,6 +114,15 @@ export function resolveFacetDefinition(semanticSpec, options = {}) {
     throw new Error(`facet field "${field}" has no values.`);
   }
   const values = resolveValues(observed, options.values);
+  validateGeneratedItemLimit(
+    values.length,
+    "Facet child count",
+    MAX_FACET_CHILDREN
+  );
+  validateWorkLimit(
+    dataset.values.length * values.length,
+    "Facet partition work"
+  );
   return cloneAndFreeze({
     id,
     data,

package/src/grammar/facets/scales.js

@@ -131,10 +131,13 @@ function continuousUnion(domains, id) {
   )) {
     throw new TypeError(`Facet shared scale "${id}" requires finite pair domains.`);
   }
-  return [
-    Math.min(...domains.map(domain => Math.min(...domain))),
-    Math.max(...domains.map(domain => Math.max(...domain)))
-  ];
+  let minimum = Infinity;
+  let maximum = -Infinity;
+  for (const domain of domains) {
+    minimum = Math.min(minimum, domain[0], domain[1]);
+    maximum = Math.max(maximum, domain[0], domain[1]);
+  }
+  return [minimum, maximum];
 }
 
 function stableUnion(domains) {

package/src/grammar/gradientProfile.js

@@ -2,8 +2,10 @@ import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
 import {
   deriveKernelDensity,
   validateDensityKernel,
-  validateDensityNormalization
+  validateDensityNormalization,
+  validateDensitySteps
 } from "./density.js";
+import { finiteMidpoint, stableFiniteMean } from "./numeric.js";
 
 export const GRADIENT_PROFILE_FIELDS = Object.freeze({
   category: "__gradientPlot_category",
@@ -15,11 +17,11 @@ export const GRADIENT_PROFILE_FIELDS = Object.freeze({
   count: "__gradientPlot_count"
 });
 
-const TRANSFORM_KEYS = Object.freeze([
+const TRANSFORM_KEYS = [
   "type", "category", "field", "bandwidth", "extent", "steps", "kernel",
   "normalization", "center", "as", "resolve", "resolved"
-]);
-const OUTPUT_KEYS = Object.freeze(Object.keys(GRADIENT_PROFILE_FIELDS));
+];
+const OUTPUT_KEYS = Object.keys(GRADIENT_PROFILE_FIELDS);
 
 function requireField(value, label) {
   if (typeof value !== "string" || value.length === 0) {
@@ -92,9 +94,7 @@ export function validateGradientProfileTransform(value) {
   if (value.extent !== "auto") {
     validatePair(value.extent, "Gradient profile extent");
   }
-  if (!Number.isInteger(value.steps) || value.steps < 2) {
-    throw new RangeError("Gradient profile steps must be an integer of at least 2.");
-  }
+  validateDensitySteps(value.steps, "Gradient profile steps");
   validateDensityKernel(value.kernel);
   validateDensityNormalization(value.normalization);
   if (!["mean", "median"].includes(value.center)) {
@@ -148,14 +148,10 @@ export function requestedGradientProfileTransform(transform) {
 }
 
 function centerOf(values, type) {
-  if (type === "mean") {
-    return values.reduce((sum, value) => sum + value, 0) / values.length;
-  }
+  if (type === "mean") return stableFiniteMean(values);
   const sorted = [...values].sort((left, right) => left - right);
   const middle = (sorted.length - 1) / 2;
-  const lower = Math.floor(middle);
-  const upper = Math.ceil(middle);
-  return (sorted[lower] + sorted[upper]) / 2;
+  return finiteMidpoint(sorted[Math.floor(middle)], sorted[Math.ceil(middle)]);
 }
 
 export function deriveGradientProfiles(rows, transform) {
@@ -178,8 +174,9 @@ export function deriveGradientProfiles(rows, transform) {
     row[transform.category] !== undefined && row[transform.category] !== null &&
     row[transform.category] !== "" && Number.isFinite(row[transform.field])
   );
-  const maximumIntensity = Math.max(
-    ...density.values.map(row => row.__gradientProfile_intensity)
+  const maximumIntensity = density.values.reduce(
+    (maximum, row) => Math.max(maximum, row.__gradientProfile_intensity),
+    -Infinity
   );
   if (!Number.isFinite(maximumIntensity) || maximumIntensity <= 0) {
     throw new Error("Gradient profile requires a positive resolved density range.");

package/src/grammar/histogram.js

@@ -1,6 +1,14 @@
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
-
-const NICE_FACTORS = Object.freeze([1, 2, 3, 5]);
+import { MAX_GENERATED_ITEMS } from "../core/validation.js";
+import {
+  alignNumericStep,
+  cleanNumericValue,
+  interpolateNumber,
+  NICE_FACTORS,
+  niceNumericStep,
+  numericExtent,
+  normalizeNumericRange
+} from "./numeric.js";
 
 function validateValues(values) {
   if (!Array.isArray(values) || !values.every(Number.isFinite)) {
@@ -23,14 +31,12 @@ export function validateHistogramBinStep(step) {
 }
 
 export function validateHistogramBinBoundaries(boundaries) {
-  if (
-    !Array.isArray(boundaries) ||
-    boundaries.length < 2 ||
-    !boundaries.every(Number.isFinite) ||
-    boundaries.some(
-      (value, index) => index > 0 && value <= boundaries[index - 1]
-    )
-  ) {
+  if (Array.isArray(boundaries) && boundaries.length > MAX_GENERATED_ITEMS + 1) {
+    throw new RangeError(
+      `Histogram bin boundaries must generate at most ${MAX_GENERATED_ITEMS} bins.`
+    );
+  }
+  if (!validBoundaries(boundaries)) {
     throw new TypeError(
       "Histogram bin boundaries must contain at least two strictly increasing finite numbers."
     );
@@ -38,6 +44,14 @@ export function validateHistogramBinBoundaries(boundaries) {
   return boundaries;
 }
 
+function validBoundaries(boundaries) {
+  return Array.isArray(boundaries) && boundaries.length >= 2 &&
+    boundaries.every(Number.isFinite) &&
+    !boundaries.some(
+      (value, index) => index > 0 && value <= boundaries[index - 1]
+    );
+}
+
 export function normalizeHistogramBin(bin = {}) {
   if (!isPlainObject(bin)) {
     throw new TypeError("Histogram bin must be a plain object.");
@@ -78,24 +92,6 @@ function validateDomain(domain) {
   return domain;
 }
 
-function firstNiceStep(rough) {
-  const power = 10 ** Math.floor(Math.log10(rough));
-  const fraction = rough / power;
-  const factor = NICE_FACTORS.find(candidate => candidate >= fraction);
-  return (factor ?? 10) * power;
-}
-
-function nextNiceStep(step) {
-  const power = 10 ** Math.floor(Math.log10(step));
-  const fraction = step / power;
-  const factor = NICE_FACTORS.find(candidate => candidate > fraction + 1e-12);
-  return (factor ?? 10) * power;
-}
-
-function normalizeBoundary(value) {
-  return Number(value.toPrecision(15));
-}
-
 function includesExtent(domain, values) {
   return values.every(value => value >= domain[0] && value <= domain[1]);
 }
@@ -122,11 +118,16 @@ function exactStepBoundaries(domain, step) {
     );
   }
   const count = Math.round((domain[1] - domain[0]) / step);
+  if (!Number.isSafeInteger(count) || count > MAX_GENERATED_ITEMS) {
+    throw new RangeError(
+      `Histogram bin step must generate at most ${MAX_GENERATED_ITEMS} bins.`
+    );
+  }
   return Array.from(
     { length: count + 1 },
     (_, index) => index === count
       ? domain[1]
-      : normalizeBoundary(domain[0] + index * step)
+      : cleanNumericValue(domain[0] + index * step, step)
   );
 }
 
@@ -144,17 +145,16 @@ function stepBins(values, step, domain, zero) {
     throw new Error("Cannot infer histogram bins from no values.");
   }
 
-  let minimum = Math.min(...values);
-  let maximum = Math.max(...values);
+  let [minimum, maximum] = numericExtent(values);
   if (zero) {
     minimum = Math.min(0, minimum);
     maximum = Math.max(0, maximum);
   }
-  let start = normalizeBoundary(Math.floor(minimum / step) * step);
-  let stop = normalizeBoundary(Math.ceil(maximum / step) * step);
+  let start = cleanNumericValue(Math.floor(minimum / step) * step, step);
+  let stop = cleanNumericValue(Math.ceil(maximum / step) * step, step);
   if (start === stop) {
-    if (stop <= 0) start = normalizeBoundary(start - step);
-    else stop = normalizeBoundary(stop + step);
+    if (stop <= 0) start = cleanNumericValue(start - step, step);
+    else stop = cleanNumericValue(stop + step, step);
   }
   const resolvedDomain = [start, stop];
   return {
@@ -183,41 +183,120 @@ function boundaryBins(values, boundaries, domain) {
 }
 
 function equalBins(domain, maxBins) {
-  const step = (domain[1] - domain[0]) / maxBins;
-  const boundaries = Array.from(
-    { length: maxBins + 1 },
-    (_, index) =>
-      index === maxBins
-        ? domain[1]
-        : normalizeBoundary(domain[0] + index * step)
-  );
-  return { domain, step, boundaries };
+  const normalized = normalizeNumericRange(domain[0], domain[1]);
+  const candidateStep = normalized.span / maxBins * normalized.scale;
+  const boundaries = [];
+  for (let index = 0; index <= maxBins; index += 1) {
+    const value = index === maxBins
+      ? domain[1]
+      : cleanNumericValue(
+        interpolateNumber(domain[0], domain[1], index / maxBins),
+        candidateStep
+      );
+    if (boundaries.length === 0 || value > boundaries.at(-1)) {
+      boundaries.push(value);
+    }
+  }
+  const step = Number.isFinite(candidateStep) && candidateStep > 0
+    ? candidateStep
+    : firstFiniteBoundaryDifference(boundaries) ?? Number.MAX_VALUE;
+  return {
+    domain: [boundaries[0], boundaries.at(-1)],
+    step,
+    boundaries
+  };
+}
+
+function firstFiniteBoundaryDifference(boundaries) {
+  for (let index = 1; index < boundaries.length; index += 1) {
+    const difference = boundaries[index] - boundaries[index - 1];
+    if (Number.isFinite(difference) && difference > 0) return difference;
+  }
+  return undefined;
+}
+
+function constantBins(value) {
+  const delta = Math.max(0.5, Math.abs(value) * Number.EPSILON);
+  let lower = value - delta;
+  let upper = value + delta;
+  if (!Number.isFinite(lower)) lower = value;
+  if (!Number.isFinite(upper)) upper = value;
+  if (lower === value) upper = value + delta;
+  if (upper === value) lower = value - delta;
+  const step = upper - lower;
+  return {
+    domain: [lower, upper],
+    step,
+    boundaries: [lower, upper]
+  };
 }
 
 function niceBins(extent, maxBins) {
-  const span = extent[1] - extent[0];
-  let step = firstNiceStep(span / maxBins);
+  const normalized = normalizeNumericRange(extent[0], extent[1]);
+  let normalizedStep = niceNumericStep(
+    normalized.span,
+    maxBins,
+    NICE_FACTORS
+  );
 
-  while (true) {
-    const start = normalizeBoundary(Math.floor(extent[0] / step) * step);
-    const stop = normalizeBoundary(Math.ceil(extent[1] / step) * step);
-    const count = Math.round((stop - start) / step);
+  for (let attempt = 0; attempt < 64; attempt += 1) {
+    const start = alignNumericStep(
+      normalized.start,
+      normalizedStep,
+      "floor"
+    );
+    const stop = alignNumericStep(
+      normalized.end,
+      normalizedStep,
+      "ceil"
+    );
+    const count = Math.round((stop - start) / normalizedStep);
 
     if (count > 0 && count <= maxBins) {
-      return {
-        domain: [start, stop],
-        step,
-        boundaries: Array.from(
-          { length: count + 1 },
-          (_, index) =>
-            index === count
-              ? stop
-              : normalizeBoundary(start + index * step)
-        )
-      };
+      const resolution = normalizedStep * normalized.scale;
+      const boundaries = [];
+      for (let index = 0; index <= count; index += 1) {
+        let value = (index === count
+          ? stop
+          : start + index * normalizedStep) * normalized.scale;
+        if (!Number.isFinite(value)) {
+          value = index === 0
+            ? extent[0]
+            : index === count ? extent[1] : value;
+        }
+        value = cleanNumericValue(value, resolution);
+        if (index === 0 && value > extent[0]) value = extent[0];
+        if (index === count && value < extent[1]) value = extent[1];
+        if (
+          Number.isFinite(value) &&
+          (boundaries.length === 0 || value > boundaries.at(-1))
+        ) {
+          boundaries.push(value);
+        }
+      }
+      if (
+        boundaries.length >= 2 &&
+        boundaries[0] <= extent[0] &&
+        boundaries.at(-1) >= extent[1]
+      ) {
+        const step = Number.isFinite(resolution) && resolution > 0
+          ? resolution
+          : firstFiniteBoundaryDifference(boundaries) ?? Number.MAX_VALUE;
+        return {
+          domain: [boundaries[0], boundaries.at(-1)],
+          step,
+          boundaries
+        };
+      }
     }
-    step = nextNiceStep(step);
+    normalizedStep = niceNumericStep(
+      normalizedStep * (1 + 1e-12),
+      1,
+      NICE_FACTORS
+    );
   }
+
+  return equalBins(extent, maxBins);
 }
 
 export function resolveHistogramBins({
@@ -254,7 +333,7 @@ export function resolveHistogramBins({
     );
   }
 
-  maxBins = normalizedBin.maxBins;
+  maxBins = Math.min(normalizedBin.maxBins, MAX_GENERATED_ITEMS);
 
   if (domain !== "auto") {
     return cloneAndFreeze(equalBins(validateDomain(domain), maxBins));
@@ -263,24 +342,14 @@ export function resolveHistogramBins({
     throw new Error("Cannot infer histogram bins from no values.");
   }
 
-  let minimum = values[0];
-  let maximum = values[0];
-
-  for (const value of values.slice(1)) {
-    minimum = Math.min(minimum, value);
-    maximum = Math.max(maximum, value);
-  }
+  let [minimum, maximum] = numericExtent(values);
 
   if (zero) {
     minimum = Math.min(0, minimum);
     maximum = Math.max(0, maximum);
   }
   if (minimum === maximum) {
-    return cloneAndFreeze({
-      domain: [minimum - 0.5, maximum + 0.5],
-      step: 1,
-      boundaries: [minimum - 0.5, maximum + 0.5]
-    });
+    return cloneAndFreeze(constantBins(minimum));
   }
 
   const resolved = nice
@@ -292,14 +361,7 @@ export function resolveHistogramBins({
 export function countHistogramBins(values, boundaries) {
   validateValues(values);
 
-  if (
-    !Array.isArray(boundaries) ||
-    boundaries.length < 2 ||
-    !boundaries.every(Number.isFinite) ||
-    boundaries.some(
-      (value, index) => index > 0 && value <= boundaries[index - 1]
-    )
-  ) {
+  if (!validBoundaries(boundaries)) {
     throw new TypeError(
       "Histogram boundaries must be ascending finite numbers."
     );

package/src/grammar/horizon.js

@@ -1,5 +1,11 @@
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
+import {
+  validateGeneratedItemLimit,
+  validateNonEmptyString as requireField
+} from "../core/validation.js";
 import { normalizePalette } from "./palettes.js";
+import { interpolateNumber, inverseLerp } from "./numeric.js";
+import { requireFiniteResult } from "./numeric.js";
 import {
   isNominalValue,
   normalizeTemporalValue
@@ -14,13 +20,6 @@ const OUTPUT_PROPERTIES = Object.freeze([
   "x", "lower", "upper", "group", "color", "sign", "band", "segment"
 ]);
 
-function requireField(value, label) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string.`);
-  }
-  return value;
-}
-
 function validateEncoding(value, role) {
   if (!isPlainObject(value)) {
     throw new TypeError(`Horizon ${role} encoding must be a plain object.`);
@@ -32,13 +31,14 @@ function validateEncoding(value, role) {
     throw new Error(`Unknown Horizon ${role} encoding property "${unknown}".`);
   }
   const field = requireField(value.field, `Horizon ${role} field`);
-  const fieldType = value.fieldType ?? (role === "x" ? "quantitative" : "quantitative");
-  const supported = role === "x"
-    ? ["quantitative", "temporal"]
-    : ["quantitative"];
-  if (!supported.includes(fieldType)) {
+  const fieldType = value.fieldType ?? "quantitative";
+  const supportsTemporal = role === "x";
+  if (
+    fieldType !== "quantitative" &&
+    (!supportsTemporal || fieldType !== "temporal")
+  ) {
     throw new Error(
-      `Horizon ${role} fieldType must be ${supported.join(" or ")}.`
+      `Horizon ${role} fieldType must be quantitative${supportsTemporal ? " or temporal" : ""}.`
     );
   }
   return { field, fieldType };
@@ -140,6 +140,7 @@ export function validateHorizonTransform(transform) {
   if (!Number.isInteger(transform.bands) || transform.bands <= 0) {
     throw new RangeError("Horizon bands must be a positive integer.");
   }
+  validateGeneratedItemLimit(transform.bands, "Horizon bands");
   if (!Number.isFinite(transform.baseline)) {
     throw new TypeError("Horizon baseline must be finite.");
   }
@@ -254,7 +255,14 @@ function splitSegments(rows, baseline) {
       flush();
       continue;
     }
-    current.push({ ...row, signed: row.y - baseline, interpolated: false });
+    current.push({
+      ...row,
+      signed: requireFiniteResult(
+        row.y - baseline,
+        "Horizon signed deviation"
+      ),
+      interpolated: false
+    });
   }
   flush();
   return segments;
@@ -267,10 +275,10 @@ function insertCrossings(points, baseline) {
     const left = points[index - 1];
     const right = points[index];
     if (left.signed * right.signed < 0) {
-      const fraction = (baseline - left.y) / (right.y - left.y);
+      const fraction = inverseLerp(baseline, left.y, right.y);
       output.push({
         sourceRowIndex: undefined,
-        x: left.x + (right.x - left.x) * fraction,
+        x: interpolateNumber(left.x, right.x, fraction),
         y: baseline,
         missing: false,
         signed: 0,
@@ -323,23 +331,51 @@ function runsForSign(points, desired) {
 }
 
 function maximumMagnitude(group) {
-  return Math.max(
-    0,
-    ...group.segments.flatMap(segment =>
-      segment.map(point => Math.abs(point.signed))
-    )
-  );
+  let maximum = 0;
+  for (const segment of group.segments ?? [group]) {
+    for (const point of segment) {
+      maximum = Math.max(maximum, Math.abs(point.signed));
+    }
+  }
+  return maximum;
 }
 
 function resolvedExtents(groups, transform) {
   if (transform.extent !== "auto") return groups.map(() => transform.extent);
   if (transform.resolve === "shared") {
-    const shared = Math.max(0, ...groups.map(maximumMagnitude));
+    let shared = 0;
+    for (const group of groups) shared = Math.max(shared, maximumMagnitude(group));
     return groups.map(() => shared);
   }
   return groups.map(maximumMagnitude);
 }
 
+function validateOutputBudget(groups, extents, transform) {
+  let count = 0;
+  for (const [groupIndex, group] of groups.entries()) {
+    const extent = extents[groupIndex];
+    if (extent === 0) continue;
+    const bandHeight = extent / transform.bands;
+    if (!(bandHeight > 0) || !Number.isFinite(bandHeight)) {
+      throw new RangeError(
+        "Horizon band height is outside the positive finite numeric range."
+      );
+    }
+    for (const sign of ["negative", "positive"]) {
+      for (const segment of group.segments) {
+        for (const run of runsForSign(segment, sign)) {
+          const magnitude = maximumMagnitude(run);
+          count += Math.min(
+            transform.bands,
+            Math.ceil(Math.min(magnitude, extent) / bandHeight)
+          ) * run.length;
+          validateGeneratedItemLimit(count, "Horizon generated row count");
+        }
+      }
+    }
+  }
+}
+
 function seriesForGroup(group, extent, transform) {
   if (extent === 0) return [];
   const bandHeight = extent / transform.bands;
@@ -437,6 +473,7 @@ export function deriveHorizon(rows, requested) {
     throw new Error("Horizon requires at least one finite y value.");
   }
   const extents = resolvedExtents(grouped, transform);
+  validateOutputBudget(grouped, extents, transform);
   const groups = grouped.map((group, index) => ({
     ...(transform.groupBy === undefined ? {} : { group: group.group }),
     extent: extents[index],

package/src/grammar/interval.js

@@ -1,10 +1,11 @@
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
 import { aggregateScalarValues } from "./aggregate.js";
+import { requireFiniteResult, stableDecimal } from "./numeric.js";
 import { studentTCriticalValue } from "./statistics/studentT.js";
 
-const CENTER_VALUES = Object.freeze(["mean", "median"]);
-const EXTENT_VALUES = Object.freeze(["stderr", "stdev", "ci", "iqr"]);
-const TRANSFORM_KEYS = Object.freeze([
+const CENTER_VALUES = ["mean", "median"];
+const EXTENT_VALUES = ["stderr", "stdev", "ci", "iqr"];
+const TRANSFORM_KEYS = [
   "type",
   "field",
   "groupBy",
@@ -12,8 +13,8 @@ const TRANSFORM_KEYS = Object.freeze([
   "extent",
   "level",
   "as"
-]);
-const OUTPUT_KEYS = Object.freeze(["center", "lower", "upper"]);
+];
+const OUTPUT_KEYS = ["center", "lower", "upper"];
 
 function nonEmptyString(value, label) {
   if (typeof value !== "string" || value.length === 0) {
@@ -154,10 +155,6 @@ function isGroupValue(value) {
     (typeof value === "number" && Number.isFinite(value));
 }
 
-function stableNumber(value) {
-  return Number(value.toFixed(12));
-}
-
 function deriveGroup(values, transform) {
   if (transform.center === "median") {
     if (values.length === 0) return undefined;
@@ -175,7 +172,11 @@ function deriveGroup(values, transform) {
       ? aggregateScalarValues(values, "stderr")
       : studentTCritical(values.length - 1, transform.level) *
         aggregateScalarValues(values, "stderr");
-  return { center, lower: center - spread, upper: center + spread };
+  return {
+    center,
+    lower: requireFiniteResult(center - spread, "Interval lower endpoint"),
+    upper: requireFiniteResult(center + spread, "Interval upper endpoint")
+  };
 }
 
 export function deriveInterval(rows, transform) {
@@ -218,9 +219,9 @@ export function deriveInterval(rows, transform) {
     if (result === undefined) continue;
     output.push({
       ...group.fields,
-      [transform.as.center]: stableNumber(result.center),
-      [transform.as.lower]: stableNumber(result.lower),
-      [transform.as.upper]: stableNumber(result.upper)
+      [transform.as.center]: stableDecimal(result.center),
+      [transform.as.lower]: stableDecimal(result.lower),
+      [transform.as.upper]: stableDecimal(result.upper)
     });
   }
   return cloneAndFreeze(output);