ggaction 0.0.16 → 0.0.18

package/src/grammar/sort.js

@@ -0,0 +1,88 @@
+import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
+import { normalizeTemporalValue } from "./scales/fields.js";
+
+const ORDERS = new Set(["ascending", "descending"]);
+const NULLS = new Set(["first", "last"]);
+const TEMPORAL_UNITS = new Set(["year", "timestamp"]);
+
+export function normalizeSortTransform({ sortBy }) {
+  if (!Array.isArray(sortBy) || sortBy.length === 0 ||
+      Array.from({ length: sortBy.length }, (_, index) => index).some(index => !Object.hasOwn(sortBy, index))) {
+    throw new TypeError("Sorted data sortBy must be a non-empty dense array.");
+  }
+  const keys = sortBy.map((key, index) => {
+    if (!isPlainObject(key)) throw new TypeError(`Sort key ${index} must be a plain object.`);
+    const unknown = Object.keys(key).find(name => !["field", "order", "nulls", "temporalUnit"].includes(name));
+    if (unknown !== undefined) throw new Error(`Unknown sort key property "${unknown}".`);
+    if (typeof key.field !== "string" || key.field.length === 0) {
+      throw new TypeError(`Sort key ${index} field must be a non-empty string.`);
+    }
+    const order = key.order ?? "ascending";
+    const nulls = key.nulls ?? "last";
+    if (!ORDERS.has(order)) throw new Error(`Unsupported sort order "${order}".`);
+    if (!NULLS.has(nulls)) throw new Error(`Unsupported sort null placement "${nulls}".`);
+    if (key.temporalUnit !== undefined && !TEMPORAL_UNITS.has(key.temporalUnit)) {
+      throw new Error(`Unsupported sort temporalUnit "${key.temporalUnit}".`);
+    }
+    return { field: key.field, order, nulls, ...(key.temporalUnit === undefined ? {} : { temporalUnit: key.temporalUnit }) };
+  });
+  if (new Set(keys.map(key => key.field)).size !== keys.length) {
+    throw new Error("Sorted data sortBy fields must be unique.");
+  }
+  return cloneAndFreeze({ type: "sort", sortBy: keys });
+}
+
+export function validateSortTransform(transform) {
+  if (!isPlainObject(transform)) throw new TypeError("Sort transform must be a plain object.");
+  const unknown = Object.keys(transform).find(key => !["type", "sortBy"].includes(key));
+  if (unknown !== undefined) throw new Error(`Unknown sort transform property "${unknown}".`);
+  if (transform.type !== "sort") throw new Error('Sort transform type must be "sort".');
+  normalizeSortTransform(transform);
+}
+
+function compareValues(left, right) {
+  if (left === right) return 0;
+  return left < right ? -1 : 1;
+}
+
+function normalizedKey(value, key, rowIndex) {
+  if (value === null || value === undefined) return { missing: true };
+  if (key.temporalUnit !== undefined) {
+    return { missing: false, value: normalizeTemporalValue(value, key.field, rowIndex, key.temporalUnit) };
+  }
+  if (!["number", "string", "boolean"].includes(typeof value) ||
+      (typeof value === "number" && !Number.isFinite(value))) {
+    throw new TypeError(`Sort field "${key.field}" requires finite number, string, boolean, or missing values at row ${rowIndex}.`);
+  }
+  return { missing: false, value, type: typeof value };
+}
+
+export function deriveSortedRows(values, transform) {
+  if (!Array.isArray(values)) throw new TypeError("Sort source values must be an array.");
+  validateSortTransform(transform);
+  const decorated = values.map((row, index) => ({
+    row,
+    index,
+    keys: transform.sortBy.map(key => normalizedKey(row[key.field], key, index))
+  }));
+  for (let keyIndex = 0; keyIndex < transform.sortBy.length; keyIndex += 1) {
+    const key = transform.sortBy[keyIndex];
+    const types = new Set(decorated.map(entry => entry.keys[keyIndex]).filter(value => !value.missing).map(value => value.type ?? "number"));
+    if (types.size > 1) throw new TypeError(`Sort field "${key.field}" contains mixed non-missing types.`);
+  }
+  decorated.sort((left, right) => {
+    for (let index = 0; index < transform.sortBy.length; index += 1) {
+      const key = transform.sortBy[index];
+      const a = left.keys[index];
+      const b = right.keys[index];
+      if (a.missing || b.missing) {
+        if (a.missing !== b.missing) return a.missing === (key.nulls === "first") ? -1 : 1;
+        continue;
+      }
+      const compared = compareValues(a.value, b.value);
+      if (compared !== 0) return key.order === "ascending" ? compared : -compared;
+    }
+    return left.index - right.index;
+  });
+  return decorated.map(entry => entry.row);
+}

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,
@@ -16,26 +19,12 @@ import {
 } from "./weightedStatistics.js";
 
 const TRANSFORM_KEYS = Object.freeze([
-  "type", "groupBy", "aggregates", "members", "weight"
+  "type", "groupBy", "aggregates", "members", "weight", "missing", "empty"
 ]);
 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;
-}
-
 function normalizeGroupBy(value) {
   if (value === undefined) return [];
   return Array.isArray(value) ? [...value] : [value];
@@ -51,7 +40,7 @@ function normalizeAggregate(value) {
   };
 }
 
-export function normalizeSummaryTransform({ groupBy, aggregates, members, weight } = {}) {
+export function normalizeSummaryTransform({ groupBy, aggregates, members, weight, missing, empty } = {}) {
   const transform = {
     type: "summary",
     groupBy: normalizeGroupBy(groupBy),
@@ -61,7 +50,9 @@ export function normalizeSummaryTransform({ groupBy, aggregates, members, weight
     ...(members === undefined ? {} : { members }),
     ...(weight === undefined
       ? {}
-      : { weight: normalizeStatisticalWeight(weight, "Summary weight") })
+      : { weight: normalizeStatisticalWeight(weight, "Summary weight") }),
+    ...(missing === undefined ? {} : { missing }),
+    ...(empty === undefined ? {} : { empty })
   };
   validateSummaryTransform(transform);
   return cloneAndFreeze(transform);
@@ -120,21 +111,15 @@ export function validateSummaryTransform(transform) {
   if (transform.weight !== undefined) {
     normalizeStatisticalWeight(transform.weight, "Summary weight");
   }
+  if (transform.missing !== undefined && !["error", "drop"].includes(transform.missing)) {
+    throw new Error('Summary missing must be "error" or "drop".');
+  }
+  if (transform.empty !== undefined && !["null", "identity"].includes(transform.empty)) {
+    throw new Error('Summary empty must be "null" or "identity".');
+  }
   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)));
@@ -169,12 +154,13 @@ function validateAggregateValues(rows, aggregate) {
 export function deriveSummaryRows(rows, transform) {
   validateSummaryTransform(transform);
   requireSourceFields(rows, transform);
+  const explicitWeighted = transform.weight !== undefined && transform.missing !== undefined;
   let weightEntries;
   if (transform.weight === undefined) {
     for (const aggregate of transform.aggregates) {
       validateAggregateValues(rows, aggregate);
     }
-  } else {
+  } else if (!explicitWeighted) {
     weightEntries = readStatisticalWeights(rows, transform.weight, "Summary").entries;
     validateWeightedNumericFields(
       weightEntries,
@@ -183,6 +169,37 @@ export function deriveSummaryRows(rows, transform) {
       ))],
       "Summary"
     );
+  } else {
+    // Explicit missing policy is evaluated per measure. Validate every
+    // nonmissing value now, while leaving nullish value/weight pairs for the
+    // reason-priority accounting below.
+    readStatisticalWeights(
+      rows.filter(row => row[transform.weight.field] !== null && row[transform.weight.field] !== undefined),
+      transform.weight,
+      "Summary"
+    );
+    for (const aggregate of transform.aggregates) {
+      if (aggregate.field === undefined) continue;
+      validateAggregateValues(
+        rows.filter(row => row[aggregate.field] !== null && row[aggregate.field] !== undefined),
+        aggregate
+      );
+    }
+  }
+  if (transform.missing === "error") {
+    if (transform.weight !== undefined) {
+      const weightIndex = rows.findIndex(row =>
+        row[transform.weight.field] === null || row[transform.weight.field] === undefined
+      );
+      if (weightIndex !== -1) {
+        throw new TypeError(`Summary weight "${transform.weight.field}" is missing at row ${weightIndex}.`);
+      }
+    }
+    for (const aggregate of transform.aggregates) {
+      if (aggregate.field === undefined) continue;
+      const index = rows.findIndex(row => row[aggregate.field] === null || row[aggregate.field] === undefined);
+      if (index !== -1) throw new TypeError(`Summary field "${aggregate.field}" is missing at row ${index}.`);
+    }
   }
 
   const groups = new Map();
@@ -212,34 +229,92 @@ export function deriveSummaryRows(rows, transform) {
     throw new RangeError(`Summary output cannot exceed ${MAX_OUTPUT_ROWS} groups.`);
   }
 
-  return [...groups.values()].map(group => {
-    const weightSummary = transform.weight === undefined
+  const units = [];
+  const values = [...groups.values()].map(group => {
+    const sharedWeightSummary = transform.weight === undefined || explicitWeighted
       ? undefined
       : summarizeStatisticalWeights(
           group.entries,
           transform.weight.kind,
           "Summary group"
         );
+    const aggregated = Object.fromEntries(transform.aggregates.map(aggregate => {
+      let missingValue = 0;
+      let missingWeight = 0;
+      let zeroWeightRows = 0;
+      let measureWeightSummary = sharedWeightSummary;
+      if (explicitWeighted) {
+        const eligible = group.rows.filter(row => {
+          if (aggregate.field !== undefined &&
+              (row[aggregate.field] === null || row[aggregate.field] === undefined)) {
+            missingValue += 1;
+            return false;
+          }
+          if (row[transform.weight.field] === null || row[transform.weight.field] === undefined) {
+            missingWeight += 1;
+            return false;
+          }
+          return true;
+        });
+        const entries = readStatisticalWeights(eligible, transform.weight, "Summary").entries;
+        zeroWeightRows = entries.filter(entry => entry.weight === 0).length;
+        measureWeightSummary = summarizeStatisticalWeights(
+          entries,
+          transform.weight.kind,
+          "Summary group"
+        );
+      }
+      let value = measureWeightSummary === undefined
+        ? aggregateRows(group.rows, aggregate.field ?? "__row", aggregate.op)
+        : calculateWeightedAggregate(
+            measureWeightSummary,
+            aggregate.field,
+            aggregate.op,
+            `Summary aggregate "${aggregate.as}"`
+          );
+      if (value === undefined && transform.empty !== undefined) {
+        const op = typeof aggregate.op === "string" ? aggregate.op : aggregate.op.op;
+        value = transform.empty === "identity" && op === "sum" ? 0 : null;
+      }
+      if (transform.missing !== undefined || transform.empty !== undefined) {
+        const missing = explicitWeighted
+          ? missingValue + missingWeight
+          : aggregate.field === undefined ? 0 : group.rows.filter(row => row[aggregate.field] === null || row[aggregate.field] === undefined).length;
+        units.push({
+          role: aggregate.as,
+          group: group.values,
+          inputRows: group.rows.length,
+          usedRows: group.rows.length - missing,
+          excludedRows: missing,
+          excludedByReason: missing === 0 ? {} : {
+            ...(missingValue === 0 && explicitWeighted ? {} : { "missing-value": explicitWeighted ? missingValue : missing }),
+            ...(missingWeight === 0 ? {} : { "missing-weight": missingWeight })
+          },
+          ...(explicitWeighted ? { zeroWeightRows } : {})
+        });
+      }
+      return [aggregate.as, value];
+    }));
     return {
       ...group.values,
-      ...Object.fromEntries(transform.aggregates.map(aggregate => [
-        aggregate.as,
-        weightSummary === undefined
-          ? aggregateRows(group.rows, aggregate.field ?? "__row", aggregate.op)
-          : calculateWeightedAggregate(
-              weightSummary,
-              aggregate.field,
-              aggregate.op,
-              `Summary aggregate "${aggregate.as}"`
-            )
-      ])),
+      ...aggregated,
       ...(transform.members === undefined
         ? {}
         : {
-            [transform.members]: weightSummary === undefined
+            [transform.members]: sharedWeightSummary === undefined
               ? group.rows
-              : weightedRows(weightSummary)
+              : weightedRows(sharedWeightSummary)
           })
     };
   });
+  if (transform.missing === undefined && transform.empty === undefined) return values;
+  return {
+    values,
+    report: cloneAndFreeze({
+      version: 1,
+      owner: { kind: "data", id: "pending" },
+      inputs: [],
+      units
+    })
+  };
 }

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";
 
@@ -75,12 +76,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 +122,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 }) };
@@ -337,3 +333,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" }),
+  sort: Object.freeze({ facetTopology: "statistical" }),
   summary: Object.freeze({ facetTopology: "statistical" }),
   stack: Object.freeze({ facetTopology: "statistical" }),
   statisticalReference: Object.freeze({ facetTopology: "statistical" }),

package/src/grammar/transforms.js

@@ -23,6 +23,7 @@ import {
   validateCompleteTransform
 } from "./complete.js";
 import {
+  normalizeFilterTransformEdit,
   normalizeFilterTransform,
   validateFilterTransform
 } from "./filter.js";
@@ -62,6 +63,7 @@ import {
   validateSummaryTransform
 } from "./summary.js";
 import { normalizeStackTransform, validateStackTransform } from "./stack.js";
+import { normalizeSortTransform, validateSortTransform } from "./sort.js";
 import { validateStatisticalReferenceTransform } from
   "./statisticalReference.js";
 import { findTransformTopology } from "./transformTopology.js";
@@ -102,15 +104,6 @@ function normalizeSimple(normalize) {
   return (transform, patch) => normalize(mergedOptions(transform, patch));
 }
 
-function normalizeFilterEdit(transform, patch) {
-  const base = replaceExclusive(
-    requestedOptions(transform),
-    patch,
-    ["oneOf", "predicate", "range"]
-  );
-  return normalizeFilterTransform({ ...base, ...patch });
-}
-
 function normalizeBinEdit(transform, patch) {
   const prior = requestedOptions(transform);
   const base = replaceExclusive(
@@ -202,17 +195,28 @@ function normalizeNormalizeEdit(transform, patch) {
 
 function normalizeRegressionEdit(transform, patch) {
   const base = { ...requestedOptions(transform) };
+  if (patch.predict === false) delete base.predict;
   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") {
+      delete base.span;
+      delete base.robustIterations;
+    }
     if (method === "loess" || base.method === "loess") {
       for (const key of [
         "confidenceMethod", "level", "confidence", "interval"
       ]) delete base[key];
     }
   }
-  return normalizeRegressionTransform({ ...base, ...patch, method });
+  if (patch.interval === false) {
+    for (const key of ["confidenceMethod", "level", "confidence"]) delete base[key];
+  }
+  return normalizeRegressionTransform({
+    ...base,
+    ...Object.fromEntries(Object.entries(patch).filter(([key, value]) => !(key === "predict" && value === false))),
+    method
+  });
 }
 
 function normalizeTimeUnitEdit(transform, patch) {
@@ -373,7 +377,7 @@ const TRANSFORM_POLICIES = Object.freeze({
     materializeOp: "materializeFilteredData",
     replayTransform: requestedTransform,
     editable: true,
-    normalizeEdit: normalizeFilterEdit,
+    normalizeEdit: normalizeFilterTransformEdit,
     outputRoles: () => ({})
   }),
   fold: Object.freeze({
@@ -442,6 +446,15 @@ const TRANSFORM_POLICIES = Object.freeze({
     normalizeEdit: normalizeRegressionEdit,
     outputRoles: () => ({})
   }),
+  sort: Object.freeze({
+    ...findTransformTopology("sort"),
+    validate: validateSortTransform,
+    materializeOp: "materializeSortedData",
+    replayTransform: requestedTransform,
+    editable: true,
+    normalizeEdit: normalizeSimple(normalizeSortTransform),
+    outputRoles: () => ({})
+  }),
   summary: Object.freeze({
     ...findTransformTopology("summary"),
     validate: validateSummaryTransform,

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)) {