ggaction 0.0.17 → 0.0.19

package/src/grammar/schemas/semanticPath.js

@@ -1,5 +1,6 @@
 import { USER_ID_SOURCE } from "../../core/identifiers.js";
 import {
+  AXIS_RESOURCE_CHANNELS,
   CARTESIAN_POSITION_CHANNELS,
   ENCODING_CHANNELS,
   SCALED_ENCODING_CHANNELS
@@ -23,7 +24,7 @@ const ENCODING_PATHS = Object.freeze([
   "encoding.color.aggregate",
   "encoding.group.fields",
   "encoding.group.inferredFrom",
-  ...["x", "y", "x2", "y2", "theta", "color"].map(channel =>
+  ...["x", "y", "x2", "y2", "theta", "color", "stroke"].map(channel =>
     `encoding.${channel}.temporalUnit`
   ),
   "encoding.pathOrder.field",
@@ -64,6 +65,8 @@ const ENTITY_PATHS = Object.freeze({
       "transform",
       "mark.type",
       "mark.missing",
+      "mark.orientation",
+      "mark.blend",
       "derivedBindings.regression",
       "layout.mode",
       ...ENCODING_PATHS
@@ -73,7 +76,7 @@ const ENTITY_PATHS = Object.freeze({
     collection: "scales",
     properties: new Set([
       "type", "domain", "range", "emptyDomain", "nice", "zero", "clamp", "reverse",
-      "unknown", "base", "exponent", "constant", "interpolate", "radialMapping", "midpoint",
+      "unknown", "base", "exponent", "constant", "interpolate", "whitePoint", "gamma", "radialMapping", "midpoint",
       "paddingInner", "paddingOuter", "padding", "align"
     ])
   },
@@ -100,6 +103,9 @@ const GUIDE_PATHS = new Set([
   "axis.parallel.coordinate",
   "axis.parallel.scales",
   "axis.parallel.titles",
+  "legend.colorSize.colorScale",
+  "legend.colorSize.sizeScale",
+  "legend.colorSize.title",
   "legend.color.scale",
   "legend.color.title",
   "legend.color.order",
@@ -136,6 +142,7 @@ const GUIDE_REMOVABLE_CONTAINERS = new Set([
   "grid.vertical",
   "grid.theta",
   "grid.radial",
+  "legend.colorSize",
   "legend.color",
   "legend.stroke",
   "legend.size",
@@ -146,6 +153,13 @@ const GUIDE_REMOVABLE_CONTAINERS = new Set([
 
 const TITLE_PATHS = new Set(["text", "subtitle"]);
 
+function isNamedAxisPath(path, container = false) {
+  const match = path.match(new RegExp(container
+    ? `^axis\\.(${USER_ID_SOURCE})$`
+    : `^axis\\.(${USER_ID_SOURCE})\\.(scale|coordinate|title|channel|position)$`));
+  return match !== null && !AXIS_RESOURCE_CHANNELS.includes(match[1]);
+}
+
 function splitPropertyPath(property) {
   return property.split(".");
 }
@@ -200,7 +214,9 @@ export function parseSemanticPath(property, { allowContainer = false } = {}) {
 
     if (
       !GUIDE_PATHS.has(propertyPath) &&
-      !(allowContainer && GUIDE_REMOVABLE_CONTAINERS.has(propertyPath))
+      !isNamedAxisPath(propertyPath) &&
+      !(allowContainer && (GUIDE_REMOVABLE_CONTAINERS.has(propertyPath) ||
+        isNamedAxisPath(propertyPath, true)))
     ) {
       throw new Error(`Unknown semantic property "${property}".`);
     }

package/src/grammar/stack.js

@@ -1,3 +1,5 @@
+import { rejectUnknownProperties as rejectUnknownKeys } from "../core/validation.js";
+import { requireStringValue as requireField } from "../core/validation.js";
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
 import { layoutSeriesPartition } from "./seriesLayout.js";
 
@@ -8,17 +10,7 @@ const AS_KEYS = Object.freeze(["start", "end", "value", "share"]);
 const MODES = new Set(["stack", "fill", "center", "diverging"]);
 const MAX_OUTPUT_ROWS = 10_000;
 
-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 normalizeAs(value, field) {
   const requested = value ?? {};

package/src/grammar/statisticalReference.js

@@ -1,3 +1,4 @@
+import { rejectUnknownProperties as rejectUnknownKeys } from "../core/validation.js";
 import { aggregateRows } from "./aggregate.js";
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
 
@@ -6,12 +7,6 @@ const SIMPLE_STATISTICS = new Set(["mean", "median", "min", "max"]);
 const POPULATIONS = new Set(["boundData", "visibleItems"]);
 const TRANSFORM_KEYS = Object.freeze(["type", "target"]);
 
-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}".`);
-  }
-}
 
 export function normalizeReferenceStatistic(value, label = "Reference statistic") {
   if (!isPlainObject(value)) {

package/src/grammar/summary.js

@@ -1,3 +1,6 @@
+import { scalarKey } 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 {
   aggregateRows,
@@ -20,21 +23,7 @@ const TRANSFORM_KEYS = Object.freeze([
 ]);
 const AGGREGATE_KEYS = Object.freeze(["op", "field", "as"]);
 const NOMINAL_OPERATIONS = new Set(["distinct", "valid", "missing"]);
-const MAX_OUTPUT_ROWS = 10_000;
-
-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;
-}
+const MAX_OUTPUT_ROWS = 30_000;
 
 function normalizeGroupBy(value) {
   if (value === undefined) return [];
@@ -131,18 +120,6 @@ export function validateSummaryTransform(transform) {
   return 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 requireSourceFields(rows, transform) {
   if (rows.length === 0) return;
   const fields = new Set(rows.flatMap(row => Object.keys(row)));

package/src/grammar/text.js

@@ -11,6 +11,11 @@ export function isSourceOwnedText(layer) {
   return layer?.mark?.type === "text" && layer.source !== undefined;
 }
 
+export const TEXT_MARK_STYLE_OPTIONS = Object.freeze([
+  "fill", "opacity", "fontSize", "fontFamily", "fontWeight",
+  "align", "baseline", "rotation", "dx", "dy", "inheritColor", "lineHeight", "blockAlign"
+]);
+
 export const DEFAULT_TEXT_MARK = cloneAndFreeze({
   fill: "#334155",
   opacity: 1,
@@ -49,6 +54,18 @@ export function formatTextValue(value, format = "auto") {
 
 export function normalizeTextMarkConfig(options, base = DEFAULT_TEXT_MARK) {
   const config = { ...base };
+  if (Object.hasOwn(options, "lineHeight")) {
+    if (!Number.isFinite(options.lineHeight) || options.lineHeight <= 0) throw new RangeError("Text lineHeight must be positive and finite.");
+    config.lineHeight = options.lineHeight;
+  }
+  if (Object.hasOwn(options, "blockAlign")) {
+    if (!["first", "middle"].includes(options.blockAlign)) throw new Error("Text blockAlign must be first or middle.");
+    config.blockAlign = options.blockAlign;
+  }
+  if (Object.hasOwn(options, "inheritColor")) {
+    if (![false, "fill", "stroke"].includes(options.inheritColor)) throw new Error("Text inheritColor must be fill, stroke, or false.");
+    config.inheritColor = options.inheritColor;
+  }
   const mapping = {
     fill: "fill",
     opacity: "opacity",
@@ -75,3 +92,5 @@ export function normalizeTextMarkConfig(options, base = DEFAULT_TEXT_MARK) {
   }
   return cloneAndFreeze(config);
 }
+
+export { resolveTextLines } from "../core/textMetrics.js";

package/src/grammar/timeUnit.js

@@ -1,3 +1,4 @@
+import { requireStringValue as requireField } from "../core/validation.js";
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
 import { normalizeTemporalValue, validateTemporalUnit } from "./scales/fields.js";
 
@@ -51,6 +52,7 @@ function formatter(timeZone) {
     try {
       value = new Intl.DateTimeFormat("en-US-u-ca-gregory-nu-latn", {
         timeZone,
+        era: "short",
         year: "numeric",
         month: "2-digit",
         day: "2-digit",
@@ -67,7 +69,7 @@ function formatter(timeZone) {
   return CALENDAR_FORMATTERS.get(timeZone);
 }
 
-function validateTimeZone(timeZone) {
+export function validateTimeZone(timeZone) {
   if (typeof timeZone !== "string" || timeZone.length === 0) {
     throw new TypeError("Time-unit timeZone must be a non-empty IANA time-zone name.");
   }
@@ -75,12 +77,6 @@ function validateTimeZone(timeZone) {
   return timeZone;
 }
 
-function requireField(value, label) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string.`);
-  }
-  return value;
-}
 
 function rejectUnknownKeys(value) {
   const unknown = Object.keys(value).find(key => !TRANSFORM_KEYS.includes(key));
@@ -127,7 +123,8 @@ export function validateTimeUnitTransform(transform) {
 }
 
 export function normalizeTimeUnitTransform(args = {}) {
-  const { field, unit, as, temporalUnit, timeZone } = args;
+  const { field, unit, temporalUnit, timeZone } = args;
+  const as = args.as === undefined ? `${field}_${unit}` : args.as;
   const transform = { type: "timeUnit", field, unit, as,
     ...(temporalUnit === undefined ? {} : { temporalUnit }),
     ...(timeZone === undefined ? {} : { timeZone }) };
@@ -182,17 +179,18 @@ export function calendarParts(timestamp, timeZone) {
   validateTimeZone(timeZone);
   const parts = Object.fromEntries(formatter(timeZone).formatToParts(timestamp)
     .filter(part => part.type !== "literal")
-    .map(part => [part.type, Number(part.value)]));
+    .map(part => [part.type, part.type === "era" ? part.value : Number(part.value)]));
+  const year = parts.era === "BC" ? 1 - parts.year : parts.year;
   const millisecond = ((timestamp % 1000) + 1000) % 1000;
   return {
-    year: parts.year,
+    year,
     month: parts.month,
     day: parts.day,
     hour: parts.hour,
     minute: parts.minute,
     second: parts.second,
     millisecond,
-    weekday: weekdayFromDate(parts.year, parts.month, parts.day)
+    weekday: weekdayFromDate(year, parts.month, parts.day)
   };
 }
 
@@ -337,3 +335,16 @@ export function deriveTimeUnitRows(rows, transform) {
   });
   return cloneAndFreeze(values);
 }
+
+export function offsetUtcTimeUnit(timestamp, unit) {
+  const date = new Date(timestamp);
+  if (unit === "year") return utcTimestamp(date.getUTCFullYear() + 1);
+  if (unit === "quarter" || unit === "month") {
+    return utcTimestamp(date.getUTCFullYear(), date.getUTCMonth() + (unit === "quarter" ? 3 : 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;
+}
+

package/src/grammar/transformKeys.js

@@ -0,0 +1,47 @@
+import { isPlainObject } from "../core/immutable.js";
+import { requireStringValue, rejectUnknownProperties } from "../core/validation.js";
+
+export 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.`
+  );
+}
+
+export 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
+  );
+}
+
+export function validateSortBy(sortBy, label) {
+  const kind = label.toLowerCase();
+  if (!Array.isArray(sortBy)) throw new TypeError(`${label} sortBy must be an array.`);
+  const fields = [];
+  sortBy.forEach((sort, index) => {
+    if (!isPlainObject(sort)) {
+      throw new TypeError(`${label} sortBy[${index}] must be a plain object.`);
+    }
+    rejectUnknownProperties(sort, ["field", "order"], `${kind} sortBy[${index}]`);
+    fields.push(requireStringValue(sort.field, `${label} sortBy[${index}].field`));
+    if (!["ascending", "descending"].includes(sort.order)) {
+      throw new Error(`Unsupported ${kind} sort order "${sort.order}".`);
+    }
+  });
+  if (new Set(fields).size !== fields.length) {
+    throw new Error(`${label} sortBy fields must be unique.`);
+  }
+}
+
+export function isGroupValue(value) {
+  return typeof value === "string" || typeof value === "boolean" ||
+    (typeof value === "number" && Number.isFinite(value));
+}

package/src/grammar/transformTopology.js

@@ -16,6 +16,7 @@ const TRANSFORM_TOPOLOGY = Object.freeze({
   markFilter: Object.freeze({ provenanceTransparent: true }),
   normalize: Object.freeze({ facetTopology: "statistical" }),
   regression: Object.freeze({ facetTopology: "statistical" }),
+  regressionStatistics: Object.freeze({ facetTopology: "statistical" }),
   sort: Object.freeze({ facetTopology: "statistical" }),
   summary: Object.freeze({ facetTopology: "statistical" }),
   stack: Object.freeze({ facetTopology: "statistical" }),

package/src/grammar/transforms.js

@@ -1,4 +1,5 @@
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
+import { validateRegressionStatisticsTransform } from "./regression/statistics.js";
 import { validateBoxTransform } from "./boxPlot.js";
 import { normalizeBinTransform, validateBinTransform } from "./bin.js";
 import {
@@ -199,8 +200,11 @@ function normalizeRegressionEdit(transform, patch) {
   const method = patch.method ?? base.method;
   if (method !== base.method) {
     if (method !== "polynomial") delete base.degree;
-    if (method !== "loess") delete base.span;
-    if (method === "loess" || base.method === "loess") {
+    if (method !== "loess") {
+      delete base.span;
+      delete base.robustIterations;
+    }
+    if (["loess", "exp"].includes(method) || ["loess", "exp"].includes(base.method)) {
       for (const key of [
         "confidenceMethod", "level", "confidence", "interval"
       ]) delete base[key];
@@ -443,6 +447,15 @@ const TRANSFORM_POLICIES = Object.freeze({
     normalizeEdit: normalizeRegressionEdit,
     outputRoles: () => ({})
   }),
+  regressionStatistics: Object.freeze({
+    ...findTransformTopology("regressionStatistics"),
+    validate: validateRegressionStatisticsTransform,
+    materializeOp: "materializeRegressionStatisticsData",
+    replayTransform: requestedTransform,
+    editable: true,
+    normalizeEdit: (transform, patch) => validateRegressionStatisticsTransform({ ...transform, ...patch }),
+    outputRoles: () => ({ count: "count", intercept: "intercept", slope: "slope", rSquared: "rSquared" })
+  }),
   sort: Object.freeze({
     ...findTransformTopology("sort"),
     validate: validateSortTransform,

package/src/grammar/valueFormat.js

@@ -1,5 +1,7 @@
 const NUMERIC_FORMAT = /^\.(0?\d|1[0-2])(f|%|e)$/;
-const TIME_DIRECTIVES = new Set(["Y", "m", "d", "b", "%"]);
+const GROUPED_NUMERIC_FORMAT = /^,(?:\.(0?\d|1[0-2])f)?$/;
+const WEEKDAY_NAMES = Object.freeze(["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]);
+const TIME_DIRECTIVES = new Set(["Y", "m", "d", "b", "a", "H", "M", "S", "L", "%"]);
 const MONTH_NAMES = Object.freeze([
   "Jan", "Feb", "Mar", "Apr", "May", "Jun",
   "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
@@ -33,12 +35,12 @@ export function validateValueFormat(format, label = "Label format", {
     if (allowDecimalsObject) return format;
   }
   if (typeof format === "string" && (
-    NUMERIC_FORMAT.test(format) || isUtcValueFormat(format)
+    NUMERIC_FORMAT.test(format) || GROUPED_NUMERIC_FORMAT.test(format) || isUtcValueFormat(format)
   )) {
     return format;
   }
   const numericCandidate = typeof format === "string"
-    ? format.match(/^\.(\d+)(f|%|e)$/)
+    ? format.match(/^,?\.(\d+)(f|%|e)$/)
     : undefined;
   if (numericCandidate && Number(numericCandidate[1]) > 12) {
     throw new RangeError(`${label} numeric format supports at most 12 decimals.`);
@@ -61,9 +63,14 @@ function formatUtcValue(value, format, label) {
     Y: pad(date.getUTCFullYear(), 4),
     m: pad(date.getUTCMonth() + 1),
     d: pad(date.getUTCDate()),
-    b: MONTH_NAMES[date.getUTCMonth()]
+    b: MONTH_NAMES[date.getUTCMonth()],
+    a: WEEKDAY_NAMES[date.getUTCDay()],
+    H: pad(date.getUTCHours()),
+    M: pad(date.getUTCMinutes()),
+    S: pad(date.getUTCSeconds()),
+    L: pad(date.getUTCMilliseconds(), 3)
   };
-  return format.replace(/%([Ymdb%])/g, (_, directive) =>
+  return format.replace(/%([YmdbaHMSL%])/g, (_, directive) =>
     directive === "%" ? "%" : values[directive]
   );
 }
@@ -98,6 +105,11 @@ export function formatValue(value, {
     throw new TypeError(`${label} "${typeof resolved === "string" ? resolved : "decimals"}" requires a finite number.`);
   }
   if (typeof resolved === "object") return value.toFixed(resolved.decimals);
+  const grouped = resolved.match(GROUPED_NUMERIC_FORMAT);
+  if (grouped) {
+    const precision = grouped[1] === undefined ? 0 : Number(grouped[1]);
+    return new Intl.NumberFormat("en-US", { useGrouping: true, minimumFractionDigits: precision, maximumFractionDigits: precision }).format(value);
+  }
   const match = resolved.match(NUMERIC_FORMAT);
   const precision = Number(match[1]);
   if (match[2] === "f") return value.toFixed(precision);

package/src/grammar/weightedStatistics.js

@@ -1,3 +1,4 @@
+import { requireStringValue as requireField } from "../core/validation.js";
 import { isPlainObject } from "../core/immutable.js";
 import {
   interpolateNumber,
@@ -15,12 +16,6 @@ export const WEIGHTED_AGGREGATE_OPERATIONS = Object.freeze([
   "stderr", "median", "q1", "q3", "quantile"
 ]);
 
-function requireField(value, label) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string.`);
-  }
-  return value;
-}
 
 export function normalizeStatisticalWeight(value, label = "Statistical weight") {
   if (!isPlainObject(value)) {

package/src/grammar/window.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 {
   maximumMagnitude,
@@ -11,8 +14,6 @@ import { normalizeTemporalValue, validateTemporalUnit } from "./scales/fields.js
 const TRANSFORM_KEYS = [
   "type", "partitionBy", "sortBy", "operations", "temporalUnit"
 ];
-const SORT_KEYS = ["field", "order"];
-const ORDER_VALUES = ["ascending", "descending"];
 const OPERATION_VALUES = [
   "rowNumber", "rank", "denseRank", "cumulativeSum", "lag", "lead",
   "movingMean", "movingSum"
@@ -30,20 +31,6 @@ const DURATION_UNITS = Object.freeze({
   day: 86_400_000
 });
 
-function requireField(value, label) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string.`);
-  }
-  return value;
-}
-
-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 validateFieldList(value, label) {
   if (
     !Array.isArray(value) ||
@@ -56,26 +43,6 @@ function validateFieldList(value, label) {
   }
 }
 
-function validateSortBy(sortBy) {
-  if (!Array.isArray(sortBy)) {
-    throw new TypeError("Window sortBy must be an array.");
-  }
-  const fields = [];
-  sortBy.forEach((sort, index) => {
-    if (!isPlainObject(sort)) {
-      throw new TypeError(`Window sortBy[${index}] must be a plain object.`);
-    }
-    rejectUnknownKeys(sort, SORT_KEYS, `window sortBy[${index}]`);
-    fields.push(requireField(sort.field, `Window sortBy[${index}].field`));
-    if (!ORDER_VALUES.includes(sort.order)) {
-      throw new Error(`Unsupported window sort order "${sort.order}".`);
-    }
-  });
-  if (new Set(fields).size !== fields.length) {
-    throw new Error("Window sortBy fields must be unique.");
-  }
-}
-
 function operationKeys(operation) {
   if (POSITION_OPERATIONS.has(operation.op)) return ["op", "as"];
   if (operation.op === "cumulativeSum") return ["op", "field", "as"];
@@ -177,7 +144,7 @@ export function validateWindowTransform(transform) {
     throw new Error(`Unsupported window transform "${transform.type}".`);
   }
   validateFieldList(transform.partitionBy, "Window partitionBy");
-  validateSortBy(transform.sortBy);
+  validateSortBy(transform.sortBy, "Window");
   validateOperations(transform.operations, transform.sortBy);
   const durationOperations = transform.operations.filter(operation =>
     MOVING_OPERATIONS.has(operation.op) && Object.hasOwn(operation.frame, "duration")
@@ -199,15 +166,6 @@ function normalizePartitionBy(value) {
   return Array.isArray(value) ? [...value] : [value];
 }
 
-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 normalizeOperations(value) {
   if (!Array.isArray(value)) return value;
   return value.map(operation => {
@@ -259,18 +217,6 @@ export function normalizeWindowTransform({
   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;