ggaction 0.0.17 → 0.0.18

package/src/grammar/lineSeries.js

@@ -29,7 +29,7 @@ function requireLineEncoding(layer) {
   const y = layer.encoding?.y;
 
   if (x === undefined) {
-    throw new Error(`Line mark "${layer.id}" requires a temporal x encoding.`);
+    throw new Error(`Line mark "${layer.id}" requires an x encoding.`);
   }
 
   const binnedAggregate =
@@ -37,10 +37,10 @@ function requireLineEncoding(layer) {
     x.bin !== undefined &&
     isAggregate(y?.aggregate);
   const aggregateMode =
-    (x?.fieldType === "temporal" && isAggregate(y?.aggregate)) ||
+    (["temporal", "nominal", "ordinal"].includes(x?.fieldType) && isAggregate(y?.aggregate)) ||
     binnedAggregate;
-  const directQuantitative =
-    x?.fieldType === "quantitative" &&
+  const directNumericY =
+    ["quantitative", "nominal", "ordinal"].includes(x?.fieldType) &&
     x.bin === undefined &&
     y?.fieldType === "quantitative" &&
     y.aggregate === undefined;
@@ -48,14 +48,14 @@ function requireLineEncoding(layer) {
     y?.aggregate === undefined &&
     ((x?.fieldType === "temporal" && y?.fieldType === "quantitative") ||
       (x?.fieldType === "quantitative" && y?.fieldType === "temporal"));
-  if (!aggregateMode && !directQuantitative && !directTemporal) {
+  if (!aggregateMode && !directNumericY && !directTemporal) {
     if (x?.fieldType === "temporal") {
       throw new Error(
         `Line mark "${layer.id}" requires a supported aggregate y encoding.`
       );
     }
     throw new Error(
-      `Line mark "${layer.id}" requires temporal/aggregate or direct quantitative x/y encodings.`
+      `Line mark "${layer.id}" requires categorical/temporal aggregate or compatible direct x/y encodings.`
     );
   }
   if (aggregateMode) {
@@ -66,7 +66,7 @@ function requireLineEncoding(layer) {
     y,
     isAggregate: aggregateMode,
     binnedAggregate,
-    directRows: directTemporal || directQuantitative,
+    directRows: directTemporal || directNumericY,
     directTemporal
   };
 }
@@ -90,9 +90,17 @@ function groupedSeries(groups, fields, dimensions) {
   return series;
 }
 
-function freezeCartesianSeries(series) {
+function freezeCartesianSeries(series, categoryOrder) {
+  const observedX = series.flatMap(item => item.values.map(value => value.x));
+  const observedSet = new Set(observedX);
+  if (categoryOrder !== undefined) {
+    const domain = new Set(categoryOrder);
+    if (observedX.some(value => !domain.has(value))) {
+      throw new Error("Line categorical x domain must contain every observed vertex.");
+    }
+  }
   return cloneAndFreeze({
-    xValues: series.flatMap(item => item.values.map(value => value.x)),
+    xValues: categoryOrder === undefined ? observedX : categoryOrder.filter(value => observedSet.has(value)),
     yValues: series.flatMap(item => item.values.map(value => value.y)),
     series
   });
@@ -122,7 +130,9 @@ function deriveCartesianLineSeries(rows, layer, options = {}) {
   if (isAggregate) {
     validateAggregateFieldValues(rows, y.field, y.fieldType);
   }
-  const xValues = x.fieldType === "temporal"
+  const categorical = ["nominal", "ordinal"].includes(x.fieldType);
+  const xValues = categorical ? readNominalField(rows, x.field)
+    : x.fieldType === "temporal"
     ? readTemporalField(rows, x.field, x.temporalUnit)
     : readQuantitativeField(rows, x.field);
   const yValues = isAggregate
@@ -130,6 +140,11 @@ function deriveCartesianLineSeries(rows, layer, options = {}) {
     : y.fieldType === "temporal"
       ? readTemporalField(rows, y.field, y.temporalUnit)
       : readQuantitativeField(rows, y.field);
+  const categoryOrder = categorical ? options.xDomain ?? [...new Set(xValues)] : undefined;
+  const ranks = new Map(categoryOrder?.map((value, index) => [value, index]));
+  const compareX = categorical
+    ? (left, right) => ranks.get(left.x) - ranks.get(right.x)
+    : (left, right) => left.x - right.x;
   const seriesFields = validatePathSeriesAppearance(rows, layer);
   const binBoundaries = binnedAggregate
     ? options.xBinBoundaries ?? resolveLineBins(rows, layer).boundaries
@@ -159,14 +174,14 @@ function deriveCartesianLineSeries(rows, layer, options = {}) {
         item.orderValues,
         pathOrder.order
       );
-      return values.length < 2 ? [] : [{ key: item.key, values }];
+      return [{ key: item.key, values }];
     });
     if (series.length === 0) {
       throw new Error(
         `Line series on mark "${layer.id}" requires at least two ordered points.`
       );
     }
-    return freezeCartesianSeries(series);
+    return freezeCartesianSeries(series, categoryOrder);
   }
 
   if (directRows) {
@@ -181,16 +196,16 @@ function deriveCartesianLineSeries(rows, layer, options = {}) {
     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]
+        orderBy === "x" ? compareX : (left, right) => left.y - right.y
       );
-      return values.length < 2 ? [] : [{ key: item.key, values }];
+      return [{ key: item.key, values }];
     });
     if (series.length === 0) {
       throw new Error(
         `Line series on mark "${layer.id}" requires at least two direct points.`
       );
     }
-    return freezeCartesianSeries(series);
+    return freezeCartesianSeries(series, categoryOrder);
   }
   const aggregateGroups = new Map();
 
@@ -241,7 +256,7 @@ function deriveCartesianLineSeries(rows, layer, options = {}) {
   }
 
   const series = [...seriesGroups.values()].flatMap(item => {
-    const values = item.values.sort((left, right) => left.x - right.x);
+    const values = item.values.sort(compareX);
 
     if (values.length < 2) {
       return [];
@@ -256,7 +271,7 @@ function deriveCartesianLineSeries(rows, layer, options = {}) {
     );
   }
 
-  return freezeCartesianSeries(series);
+  return freezeCartesianSeries(series, categoryOrder);
 }
 
 function requirePolarLineEncoding(layer) {

package/src/grammar/markLabels.js

@@ -35,7 +35,8 @@ export function normalizeMarkLabelContent(source, { content, normalizeBy }) {
   }
   if (source.mark.type === "bar") {
     const grain = resolveBarGrain(source);
-    if (grain === BAR_GRAINS.ranged) {
+    if (grain === BAR_GRAINS.ranged || grain === BAR_GRAINS.centered &&
+        source.encoding[`${resolveBarChannels(source).measure}2`] !== undefined) {
       throw new Error("Ranged Bar text requires an explicit field or value.");
     }
     if (content === "category" && grain === BAR_GRAINS.histogram) {
@@ -63,10 +64,12 @@ function itemValue(source, item) {
       );
     }
     const measure = source.encoding[resolveBarChannels(source).measure];
+    if (resolveBarGrain(source) === BAR_GRAINS.centered) return item.channels[`${resolveBarChannels(source).measure}2`];
     return measure.aggregate === "count" ? item.members.length
       : aggregateRows(item.members, measure.field, measure.aggregate);
   }
-  if (source.encoding?.radius !== undefined) return item.channels.radius;
+  if (source.encoding?.radius !== undefined && source.encoding.theta.fieldType !== "quantitative" &&
+      source.encoding.theta.aggregate === undefined) return item.channels.radius;
   const theta = source.encoding.theta;
   if (theta.fieldType === "quantitative") return item.channels.theta;
   return theta.aggregate === "count" ? item.members.length

package/src/grammar/normalize.js

@@ -1,3 +1,6 @@
+import { scalarKey, normalizeSortBy, validateSortBy } from "./transformKeys.js";
+import { rejectUnknownProperties as rejectUnknownKeys } from "../core/validation.js";
+import { requireStringValue as requireField } from "../core/validation.js";
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
 import {
   inverseLerp,
@@ -15,23 +18,9 @@ const METHODS = Object.freeze([
   "share", "zscore", "minmax", "index", "change", "percentChange"
 ]);
 const ZERO_POLICIES = Object.freeze(["error", "null", "zero"]);
-const SORT_KEYS = Object.freeze(["field", "order"]);
-const ORDERS = Object.freeze(["ascending", "descending"]);
 const BASELINE_KEYS = Object.freeze(["position", "value"]);
 const BASELINE_METHODS = new Set(["index", "change", "percentChange"]);
 
-function rejectUnknownKeys(value, supported, label) {
-  const unknown = Object.keys(value).find(key => !supported.includes(key));
-  if (unknown !== undefined) throw new Error(`Unknown ${label} property "${unknown}".`);
-}
-
-function requireField(value, label) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string.`);
-  }
-  return value;
-}
-
 function normalizeGroupBy(value) {
   if (value === undefined) return [];
   return Array.isArray(value) ? [...value] : [value];
@@ -48,33 +37,6 @@ function validateGroupBy(groupBy) {
   }
 }
 
-function normalizeSortBy(value) {
-  if (value === undefined) return [];
-  if (!Array.isArray(value)) return value;
-  return value.map(sort => isPlainObject(sort)
-    ? { ...sort, order: sort.order ?? "ascending" }
-    : sort
-  );
-}
-
-function validateSortBy(sortBy) {
-  if (!Array.isArray(sortBy)) throw new TypeError("Normalize sortBy must be an array.");
-  const fields = [];
-  sortBy.forEach((sort, index) => {
-    if (!isPlainObject(sort)) {
-      throw new TypeError(`Normalize sortBy[${index}] must be a plain object.`);
-    }
-    rejectUnknownKeys(sort, SORT_KEYS, `normalize sortBy[${index}]`);
-    fields.push(requireField(sort.field, `Normalize sortBy[${index}].field`));
-    if (!ORDERS.includes(sort.order)) {
-      throw new Error(`Unsupported normalize sort order "${sort.order}".`);
-    }
-  });
-  if (new Set(fields).size !== fields.length) {
-    throw new Error("Normalize sortBy fields must be unique.");
-  }
-}
-
 function normalizeBaseline(value) {
   if (!isPlainObject(value)) return value;
   return { ...value };
@@ -136,7 +98,7 @@ export function validateNormalizeTransform(transform) {
     throw new Error("Normalize zeroDenominator is not available for change.");
   }
   if (BASELINE_METHODS.has(transform.method)) {
-    validateSortBy(transform.sortBy);
+    validateSortBy(transform.sortBy, "Normalize");
     validateBaseline(transform.baseline, transform.sortBy);
   } else {
     if (hasBaseline) {
@@ -184,18 +146,6 @@ export function normalizeNormalizeTransform(args = {}) {
   return cloneAndFreeze(transform);
 }
 
-function scalarKey(value, label) {
-  if (value === null) return "null";
-  if (typeof value === "string") return `string:${value.length}:${value}`;
-  if (typeof value === "boolean") return `boolean:${value}`;
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return `number:${Object.is(value, -0) ? 0 : value}`;
-  }
-  throw new TypeError(
-    `${label} must contain null, strings, booleans, or finite numbers.`
-  );
-}
-
 function compareScalar(left, right, label) {
   const leftMissing = left === null || left === undefined;
   const rightMissing = right === null || right === undefined;

package/src/grammar/numeric.js

@@ -1,290 +1 @@
-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));
-}
+const q=Object.freeze([1,2,3,5]);function h(t,e){if(!Array.isArray(t)||!t.every(Number.isFinite))throw new TypeError(`${e} must contain finite numbers.`)}function p(t){return new RangeError(`${t} is outside the finite numeric range.`)}function x(t,e=1){let n=0,r=0;for(const i of t){const o=i/e,c=n+o;r+=Math.abs(n)>=Math.abs(o)?n-c+o:o-c+n,n=c}return n+r}function f(t){let e=0;for(const n of t)e=Math.max(e,Math.abs(n));return e}function y(t,e="Numeric values"){h(t,e);const n=f(t)||1;return{scale:n,total:x(t,n)}}function b(t,e="Numeric result"){if(!Number.isFinite(t))throw p(e);return t===0?0:t}function N(t,e,n="Numeric result"){if(!Number.isFinite(t)||!Number.isFinite(e)||e<0)throw p(n);return b(t*e,n)}function d(t,e,n=1){h(t,e);const r=t.reduce((o,c)=>o+c,0);if(Number.isFinite(r))return r===0?0:r/n;const i=f(t)||1;return N(x(t,i)/n,i,e)}function $(t,e="Numeric sum"){return d(t,e)}function z(t,e="Numeric sum"){const n=y(t,e);let r=0,i=0,o=0;return t.map(c=>{r+=c;const u=c/n.scale,s=i+u;return o+=Math.abs(i)>=Math.abs(u)?i-s+u:u-s+i,i=s,Number.isFinite(r)?r===0?0:r:N(i+o,n.scale,e)})}function R(t,e="Numeric mean"){if(h(t,e),t.length===0)throw new RangeError(`${e} requires at least one value.`);return d(t,e,t.length)}function P(t,e="Numeric square sum"){h(t,e);const n=t.reduce((c,u)=>c+u**2,0);if(Number.isFinite(n))return n;const r=f(t);if(r===0)return 0;const i=t.reduce((c,u)=>c+(u/r)**2,0),o=N(Math.sqrt(i),r,e);return b(o**2,e)}function A(t,{sample:e=!1,divisor:n=1,label:r="Numeric deviation"}={}){if(!Number.isFinite(n)||n<=0)throw new RangeError(`${r} divisor must be positive and finite.`);const i=t.length-(e?1:0);if(i<=0)throw new RangeError(`${r} requires more values.`);const o=R(t,`${r} mean`),c=t.map(a=>a-o),u=c.reduce((a,M)=>a+M**2,0);if(Number.isFinite(u))return{mean:o,deviation:Math.sqrt(u/i)/n,squared:u};const s=c.every(Number.isFinite),m=s?f(c):Math.max(Math.abs(o),f(t));if(m===0)return{mean:o,deviation:0};const g=t.reduce((a,M,S)=>{const w=s?c[S]/m:M/m-o/m;return a+w**2},0),l=N(Math.sqrt(g/i)/n,m,r);return{mean:o,deviation:l}}function D(t,e){const n=(t.length-1)*e,r=Math.floor(n),i=Math.ceil(n);return F(t[r],t[i],n-r)}function I(t){let e=1/0,n=-1/0;for(const r of t)e=Math.min(e,r),n=Math.max(n,r);return[e,n]}function C(t,e){const n=Math.max(Math.abs(t),Math.abs(e));if(n===0)return{scale:1,start:0,end:0,span:0};const r=10**Math.floor(Math.log10(n)),i=Number.isFinite(r)&&r>0?r:n;return t/=i,e/=i,{scale:i,start:t,end:e,span:e-t}}function O(t,e=5,n=q){if(!Number.isFinite(t)||t<=0)throw new RangeError("Nice numeric span must be positive and finite.");const r=t/Math.max(1,e),i=10**Math.floor(Math.log10(r)),o=r/i;return(n.find(u=>u>=o)??10)*i}function T(t,e,n){let r=t/e;const i=Math.round(r);return Math.abs(r-i)<=1e-10&&(r=i),(n==="floor"?Math.floor(r):Math.ceil(r))*e}function E(t,e){if(!Number.isFinite(t)||t===0)return t===0?0:t;const n=Number(t.toPrecision(15));return Number.isFinite(e)&&e>0&&Math.abs(n-t)<=e*1e-10?n:t}function j(t,e,n){if(t===e)return 0;if(t===n)return 1;const r=n-e,i=t-e;if(Number.isFinite(r)&&r!==0&&Number.isFinite(i))return i/r;const o=Math.max(Math.abs(t),Math.abs(e),Math.abs(n));return(t/o-e/o)/(n/o-e/o)}function F(t,e,n){let r=n===0?t:n===1?e:void 0;if(r===void 0){const i=e-t;if(Number.isFinite(i))r=t+n*i;else{const o=Math.max(Math.abs(t),Math.abs(e));r=o*(t/o*(1-n)+e/o*n)}}return b(r,"Numeric interpolation")}function L(t,e){const n=t+e,r=Number.isFinite(n)?n/2:t/2+e/2;return b(r,"Numeric midpoint")}function V(t,e,n,r="Numeric range"){const i=Math.abs((e-t)/(n-1)),o=[],c=Math.sign(e-t);for(let u=0;u<n;u+=1){const s=E(F(t,e,u/(n-1)),i);if(!Number.isFinite(s)||c!==0&&u>0&&c*(s-o[u-1])<=0)throw new RangeError(`${r} cannot represent ${n} distinct samples.`);o.push(s)}return o}function _(t,e){let n=t.map(e??(i=>String(+i.toPrecision(3))));const r=()=>n.every((i,o)=>o===0||t[o]===t[o-1]||i!==n[o-1]);for(let i=4;!r()&&i<=17;i+=1)n=t.map(o=>String(+o.toPrecision(i)));return r()?n:t.map(String)}function k(t,e=12){if(t===0)return 0;const n=10**-e;return Math.abs(t)<n?Number(t.toPrecision(e)):Number(t.toFixed(e))}export{q as NICE_FACTORS,T as alignNumericStep,E as cleanNumericValue,L as finiteMidpoint,_ as formatDistinctNumericSamples,F as interpolateNumber,j as inverseLerp,f as maximumMagnitude,O as niceNumericStep,C as normalizeNumericRange,y as normalizedFiniteSum,I as numericExtent,D as quantileSorted,b as requireFiniteResult,N as restoreFiniteScale,V as sampleNumericRange,k as stableDecimal,A as stableFiniteDeviation,R as stableFiniteMean,z as stableFinitePrefixSums,P as stableFiniteSquareSum,$ as stableFiniteSum};

package/src/grammar/parallelCoordinates.js

@@ -1,3 +1,4 @@
+import { requireStringValue as nonEmptyString } from "../core/validation.js";
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
 import { validateUserId } from "../core/identifiers.js";
 import { validateOptionObject } from "../core/validation.js";
@@ -18,12 +19,6 @@ const DIMENSION_SCALE_OPTIONS = Object.freeze([
   "padding", "align", "unknown"
 ]);
 
-function nonEmptyString(value, label) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string.`);
-  }
-  return value;
-}
 
 export function validateParallelKeyField(value) {
   return nonEmptyString(value, "Parallel key field");

package/src/grammar/parseTime.js

@@ -0,0 +1,41 @@
+import { normalizeTemporalValue } from "./scales/fields.js";
+
+export const PARSE_TIME_FORMATS = Object.freeze([
+  "auto", "%Y-%m-%d", "%d/%m/%Y", "%m/%d/%Y"
+]);
+
+export function validateParseTimeFormat(format = "auto") {
+  if (!PARSE_TIME_FORMATS.includes(format)) {
+    throw new Error(`Unsupported parseTime format "${format}".`);
+  }
+  return format;
+}
+
+// Explicit calendar formats are UTC and reject rollover, rather than guessing
+// the day/month order. Invalid or nullish values remain missing data as null.
+export function parseTimeValue(value, format = "auto") {
+  validateParseTimeFormat(format);
+  if (value === null || value === undefined) return null;
+  if (format === "auto") {
+    try { return normalizeTemporalValue(value); }
+    catch (error) {
+      if (error instanceof TypeError || error instanceof RangeError) return null;
+      throw error;
+    }
+  }
+  if (typeof value !== "string") return null;
+  const match = (format === "%Y-%m-%d"
+    ? /^(\d{4})-(\d{1,2})-(\d{1,2})$/
+    : /^(\d{1,2})\/(\d{1,2})\/(\d{4})$/).exec(value.trim());
+  if (!match) return null;
+  const numbers = match.slice(1).map(Number);
+  const [year, month, day] = format === "%Y-%m-%d" ? numbers
+    : format === "%d/%m/%Y" ? [numbers[2], numbers[1], numbers[0]]
+      : [numbers[2], numbers[0], numbers[1]];
+  const date = new Date(0);
+  date.setUTCFullYear(year, month - 1, day);
+  date.setUTCHours(0, 0, 0, 0);
+  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1
+    && date.getUTCDate() === day && Number.isFinite(date.getTime())
+    ? date.getTime() : null;
+}

package/src/grammar/pathCommands.js

@@ -1,6 +1,12 @@
 import { freezeOwned, isPlainObject } from "../core/immutable.js";
 import { validateGeneratedItemLimit } from "../core/validation.js";
 
+export const MAX_PATH_COMMANDS = 20_000;
+
+export function validatePathCommandCount(count, label) {
+  return validateGeneratedItemLimit(count, label, MAX_PATH_COMMANDS);
+}
+
 const COMMAND_KEYS = Object.freeze({
   M: Object.freeze(["op", "x", "y"]),
   L: Object.freeze(["op", "x", "y"]),
@@ -35,14 +41,15 @@ function validateCommand(command, index) {
 }
 
 export function validatePathCommands(commands) {
-  if (!Array.isArray(commands) || commands.length < 2) {
-    throw new TypeError("path.commands must contain at least two commands.");
+  if (!Array.isArray(commands) || commands.length < 1) {
+    throw new TypeError("path.commands must contain at least one command.");
   }
-  validateGeneratedItemLimit(commands.length, "path.commands length");
+  validatePathCommandCount(commands.length, "path.commands length");
   commands.forEach(validateCommand);
   if (commands[0].op !== "M") {
     throw new Error("path.commands must start with M.");
   }
+  if (commands.length === 1) return commands;
   if (commands.slice(1).some(command => command.op === "M")) {
     throw new Error("path.commands supports one subpath and only one initial M.");
   }
@@ -79,7 +86,7 @@ export function buildLinearPathCommands(points, { close = false } = {}) {
   if (typeof close !== "boolean") {
     throw new TypeError("Linear path close must be a boolean.");
   }
-  validateGeneratedItemLimit(
+  validatePathCommandCount(
     points.length + Number(close),
     "Linear path command count"
   );