ggaction 0.0.17 → 0.0.18

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/transforms.js

@@ -199,7 +199,10 @@ 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") {
+      delete base.span;
+      delete base.robustIterations;
+    }
     if (method === "loess" || base.method === "loess") {
       for (const key of [
         "confidenceMethod", "level", "confidence", "interval"

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;