ggaction 0.0.20 → 0.0.22

package/src/grammar/facets/legendIntent.js

@@ -1,17 +1,19 @@
 import { isPlainObject } from "../../core/immutable.js";
+import {validateLegendSpacing} from "../legendSpacing.js";
 import { validateOptionObject, validateNonEmptyString } from "../../core/validation.js";
 import { validateUserId } from "../../core/identifiers.js";
 import { LEGEND_CONFIG_KINDS, LEGEND_POSITIONS } from "../../core/vocabulary.js";
 import { describeLegendBlock } from "../legendBlocks.js";
 import { validateLegendGroupState } from "../legendGroups.js";
 import { resolveSharedFacetLegends, sameFacetGuideValue as same } from "./guides.js";
+import { normalizeDisplayLabelMap } from "../displayLabels.js";
 
 const CONFIG_KEYS = Object.freeze([
   "kind", "target", "channels", "scales", "scale", "field", "fieldType", "domain", "title", "titleVisible",
   "inferredTitle", "inferredSymbol", "inferredStrokeWidth", "inferredOffset", "position", "align", "offset", "direction", "columns",
-  "titlePosition", "symbol", "labels", "titleStyle", "itemGap", "layout", "overflow", "border", "gradient",
+  "titlePosition", "symbol", "labels", "titleStyle", "itemGap", "rowPadding", "titlePadding", "layout", "overflow", "border", "gradient",
   "count", "sampling", "representation", "gradientDirection", "inheritAppearance", "inheritPosition", "blockOverrides",
-  "combine", "sizeAreas", "clipHeight"
+  "combine", "sizeAreas", "clipHeight", "defaultLabelMap"
 ]);
 
 export function isAuthoredFacetLegend(value) {
@@ -31,6 +33,8 @@ export function validateAuthoredFacetLegend(program, intent) {
     validateOptionObject(block, ["config", "guide"], "Stored parent legend block");
     validateOptionObject(block.config, kind === "colorSize" ? [...CONFIG_KEYS, "colorScale", "sizeScale"] : CONFIG_KEYS, "Stored parent legend config");
     const config = block.config;
+    validateLegendSpacing(kind,config);
+    if (config.defaultLabelMap !== undefined) normalizeDisplayLabelMap(config.defaultLabelMap, "Stored inferred legend labels");
     validateUserId(config.target, "Parent legend target");
     if (!LEGEND_POSITIONS.includes(config.position)) throw new Error("Stored parent legend requires a native position.");
     for (const flag of ["inferredTitle", "inferredSymbol", "inferredStrokeWidth", "inferredOffset", "titleVisible", "inheritAppearance", "inheritPosition"]) {

package/src/grammar/facets/scales.js

@@ -89,17 +89,37 @@ export function normalizeFacetScalePolicies(semanticSpec, requested = {}) {
       );
     }
   }
+  const inferred = { ...requested };
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const [id, channelSet] of used) {
+      const attached = [...channelSet];
+      const policies = [...new Set(attached
+        .filter(channel => inferred[channel] !== undefined)
+        .map(channel => inferred[channel]))];
+      if (policies.length > 1) {
+        throw new Error(
+          `Facet scale "${id}" has conflicting channel policies for ${attached.join(", ")}.`
+        );
+      }
+      if (policies.length === 1) for (const channel of attached) {
+        if (inferred[channel] === undefined) {
+          inferred[channel] = policies[0];
+          changed = true;
+        }
+      }
+    }
+  }
+  Object.assign(channels, inferred);
   const scalePolicies = {};
   for (const [id, channelSet] of used) {
     const attached = [...channelSet];
-    const policies = [...new Set(attached.map(channel => channels[channel]))];
-    if (policies.length !== 1) {
-      throw new Error(
-        `Facet scale "${id}" has conflicting channel policies for ${attached.join(", ")}.`
-      );
-    }
+    // One semantic scale cannot have different resolutions through its aliases.
+    // An explicitly chosen channel policy also owns omitted aliases; only
+    // contradictory explicit requests are ambiguous.
     scalePolicies[id] = {
-      policy: policies[0],
+      policy: channels[attached[0]],
       channels: attached
     };
   }

package/src/grammar/flatten.js

@@ -0,0 +1,85 @@
+import { rejectUnknownProperties, requireStringValue } from "../core/validation.js";
+import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
+
+const KEYS = Object.freeze(["type", "fields", "as"]);
+const MAX_FIELDS = 64;
+const MAX_OUTPUT_ROWS = 10_000;
+
+export function normalizeFlattenTransform({ fields, as } = {}) {
+  const aliases = as === undefined ? fields : as;
+  const transform = {
+    type: "flatten",
+    fields: Array.isArray(fields) ? [...fields] : fields,
+    as: Array.isArray(aliases) ? [...aliases] : aliases
+  };
+  validateFlattenTransform(transform);
+  return cloneAndFreeze(transform);
+}
+
+export function validateFlattenTransform(transform) {
+  if (!isPlainObject(transform)) {
+    throw new TypeError("Flatten transform must be a plain object.");
+  }
+  rejectUnknownProperties(transform, KEYS, "flatten transform");
+  if (transform.type !== "flatten") {
+    throw new Error(`Unsupported flatten transform "${transform.type}".`);
+  }
+  if (!Array.isArray(transform.fields) || transform.fields.length === 0) {
+    throw new TypeError("Flatten fields must be a non-empty array.");
+  }
+  if (transform.fields.length > MAX_FIELDS) {
+    throw new RangeError(`Flatten fields cannot contain more than ${MAX_FIELDS} entries.`);
+  }
+  if (!Array.isArray(transform.as) || transform.as.length !== transform.fields.length) {
+    throw new TypeError("Flatten as must be an array with one alias per field.");
+  }
+  for (const key of ["fields", "as"]) {
+    for (const [index, field] of transform[key].entries()) {
+      requireStringValue(field, `Flatten ${key}[${index}]`);
+    }
+    if (new Set(transform[key]).size !== transform[key].length) {
+      throw new Error(`Flatten ${key} must be unique.`);
+    }
+  }
+  return transform;
+}
+
+export function deriveFlattenRows(rows, transform) {
+  validateFlattenTransform(transform);
+  const selected = new Set(transform.fields);
+  const existing = new Set(rows.flatMap(row => Object.keys(row)));
+  for (const name of transform.as) {
+    if (existing.has(name) && !selected.has(name)) {
+      throw new Error(`Flatten output field "${name}" already exists outside the selected fields.`);
+    }
+  }
+  let total = 0;
+  const lengths = rows.map((row, rowIndex) => {
+    let length = 0;
+    for (const field of transform.fields) {
+      const value = row[field];
+      if (value === undefined || value === null) continue;
+      if (!Array.isArray(value)) {
+        throw new TypeError(`Flatten field "${field}" must be an array at row ${rowIndex}.`);
+      }
+      length = Math.max(length, value.length);
+    }
+    total += length;
+    if (total > MAX_OUTPUT_ROWS) {
+      throw new RangeError(`Flatten output cannot exceed ${MAX_OUTPUT_ROWS} rows.`);
+    }
+    return length;
+  });
+  const output = [];
+  rows.forEach((row, rowIndex) => {
+    for (let index = 0; index < lengths[rowIndex]; index += 1) {
+      const next = { ...row };
+      transform.fields.forEach((field, fieldIndex) => {
+        const values = row[field];
+        next[transform.as[fieldIndex]] = values?.[index] ?? null;
+      });
+      output.push(next);
+    }
+  });
+  return output;
+}

package/src/grammar/histogram.js

@@ -1,5 +1,6 @@
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
 import { MAX_GENERATED_ITEMS } from "../core/validation.js";
+import { niceLinearCountDomain, normalizeScaleNice } from "./scales/continuous.js";
 import {
   alignNumericStep,
   cleanNumericValue,
@@ -299,7 +300,18 @@ function niceBins(extent, maxBins) {
   return equalBins(extent, maxBins);
 }
 
-export function resolveHistogramBins({
+export function resolveHistogramBins(options) {
+  if (isPlainObject(options.nice)) {
+    const { count } = normalizeScaleNice("linear", options.nice);
+    const bins = resolveBooleanHistogramBins({ ...options, nice: true });
+    return options.domain === undefined || options.domain === "auto"
+      ? cloneAndFreeze({ ...bins, domain: niceLinearCountDomain(bins.domain, count) })
+      : bins;
+  }
+  return resolveBooleanHistogramBins(options);
+}
+
+function resolveBooleanHistogramBins({
   values,
   bin,
   maxBins,