ggaction 0.0.17 → 0.0.19

package/src/core/compositionState.js

@@ -202,10 +202,10 @@ function validateFacetSpec(compositionSpec) {
     !isPlainObject(guides) ||
     Object.keys(guides).some(key => !["axes", "legend"].includes(key)) ||
     !["each", "outer"].includes(guides.axes) ||
-    ![false, "shared"].includes(guides.legend)
+    (![false, "shared"].includes(guides.legend) && !isPlainObject(guides.legend))
   ) {
     throw new Error(
-      'compositionSpec.facet.guides requires axes "each" or "outer" and legend false or "shared".'
+      'compositionSpec.facet.guides requires axes "each" or "outer" and legend false, "shared", or parent legend options.'
     );
   }
 }
@@ -272,7 +272,7 @@ export function ownCompositionSpec(compositionSpec, children) {
   }
   const allowed = [
     "id", "type", "direction", "children", "columns", "gap", "align",
-    "padding", "facet"
+    "padding", "facet", "spacing"
   ];
   const unknown = Object.keys(compositionSpec).find(key => !allowed.includes(key));
   if (unknown !== undefined) {
@@ -282,6 +282,9 @@ export function ownCompositionSpec(compositionSpec, children) {
     throw new TypeError("compositionSpec.id must be a non-empty string.");
   }
   const facet = compositionSpec.type === "facet";
+  if (compositionSpec.spacing !== undefined && (!facet || !["plot", "canvas"].includes(compositionSpec.spacing))) {
+    throw new Error("compositionSpec.spacing requires a facet and canvas or plot spacing.");
+  }
   if (compositionSpec.type !== undefined && !facet) {
     throw new Error(`Unknown compositionSpec type "${compositionSpec.type}".`);
   }

package/src/core/font.js

@@ -5,8 +5,15 @@ export function normalizeRendererFontWeight(fontWeight) {
   return Math.min(900, Math.max(100, Math.round(fontWeight / 100) * 100));
 }
 
-export function textMetricKey({ text, fontFamily, fontSize, fontWeight }) {
-  return JSON.stringify([text, fontFamily, fontSize, fontWeight]);
+export function validateFontStyle(value, label = "Text") {
+  if (!["normal", "italic"].includes(value)) {
+    throw new Error(`${label} fontStyle must be normal or italic.`);
+  }
+  return value;
+}
+
+export function textMetricKey({ text, fontFamily, fontSize, fontWeight, fontStyle = "normal" }) {
+  return JSON.stringify([text, fontFamily, fontSize, fontWeight, fontStyle]);
 }
 
 export function textMetricFontWeight(value = "normal") {

package/src/core/graphicProperties.js

@@ -0,0 +1 @@
+function n(e,t,i){for(const[r,c]of Object.entries(i))e=e.editGraphics({target:t,property:r,value:c});return e}export{n as editGraphicProperties};

package/src/core/optionRequirements.js

@@ -1,6 +1,7 @@
 // The method's value-producing contract is shared by runtime validation and
 // authoring knowledge; editing can inherit these values from stored state.
 export const IMPUTE_REQUIRED_OPTIONS = Object.freeze({
+  mean: Object.freeze([]),
   constant: Object.freeze(["value"]),
   forward: Object.freeze(["sortBy"]),
   backward: Object.freeze(["sortBy"]),

package/src/core/programState.js

@@ -44,6 +44,10 @@ export function releaseNamedResourceOwnership(program, { kind, id, dataOwner })
     materializationConfigs,
     ["calculations", "datasets", dataOwner?.current ?? id]
   ).value;
+  materializationConfigs = removeMaterializationConfig(
+    materializationConfigs,
+    ["regressionFits", dataOwner?.current ?? id]
+  ).value;
   const context = program.context.currentData === id
     ? freezeOwned({ ...program.context, currentData: undefined })
     : program.context;

package/src/core/resourceReferences.js

@@ -97,7 +97,7 @@ export function collectSemanticScaleReferences(program) {
     }
   }
   collectKnownKeys(program.semanticSpec.guides, [], (key, value, path) => {
-    if (key === "scale") {
+    if (["scale", "colorScale", "sizeScale"].includes(key)) {
       append(references, reference(
         "scale", value, "semanticGuide", "guides", path
       ));
@@ -199,13 +199,16 @@ export function collectMarkConfigReferences(program) {
 
 export function collectGuideConfigReferences(program) {
   const references = [];
+  for (const target of Object.keys(program.guideConfigs?.legendGroups ?? {})) {
+    append(references, reference("mark", target, "legend", target, ["legendGroups", target]));
+  }
   for (const [family, configs] of Object.entries(program.guideConfigs ?? {})) {
     collectKnownKeys(configs, [], (key, value, path, parentPath) => {
       const ownerId = parentPath.length === 0 ? family : parentPath.join(".");
       const relativePath = parentPath.length === 0
         ? path
         : path.slice(parentPath.length);
-      if (key === "scale") {
+      if (["scale", "colorScale", "sizeScale"].includes(key)) {
         append(references, reference(
           "scale", value, family, ownerId, relativePath
         ));

package/src/core/textMetricProfile.js

@@ -2,7 +2,7 @@ import { cloneAndFreeze } from "./immutable.js";
 import { validateUserId } from "./identifiers.js";
 import { validateOptionObject, validatePositiveFinite, validateNonNegativeFinite, validateNonEmptyString } from "./validation.js";
 
-import { textMetricKey } from "./font.js";
+import { textMetricKey, validateFontStyle } from "./font.js";
 
 export function normalizeTextMetricProfile(profile) {
   validateOptionObject(profile, ["schemaVersion", "id", "measurements"], "Text metrics profile");
@@ -11,7 +11,7 @@ export function normalizeTextMetricProfile(profile) {
   if (!Array.isArray(profile.measurements)) throw new TypeError("Text metrics measurements must be an array.");
   const seen = new Set();
   for (const measurement of profile.measurements) {
-    validateOptionObject(measurement, ["text", "fontFamily", "fontSize", "fontWeight", "width"], "Text measurement");
+    validateOptionObject(measurement, ["text", "fontFamily", "fontSize", "fontWeight", "fontStyle", "width"], "Text measurement");
     if (typeof measurement.text !== "string") throw new TypeError("Text measurement text must be a string.");
     validateNonEmptyString(measurement.fontFamily, "Text measurement fontFamily");
     validatePositiveFinite(measurement.fontSize, "Text measurement fontSize");
@@ -20,6 +20,7 @@ export function normalizeTextMetricProfile(profile) {
         measurement.fontWeight > 900 || measurement.fontWeight % 100 !== 0) {
       throw new RangeError("Text measurement fontWeight must be 100–900 in steps of 100.");
     }
+    if (measurement.fontStyle !== undefined) validateFontStyle(measurement.fontStyle, "Text measurement");
     const key = textMetricKey(measurement);
     if (seen.has(key)) throw new Error("Duplicate text measurement combination.");
     seen.add(key);

package/src/core/textMetrics.js

@@ -1,3 +1,4 @@
+import { validateGeneratedItemLimit } from "./validation.js";
 import { DEFAULT_FONT_FAMILY, textMetricFontWeight, textMetricKey } from "./font.js";
 
 import { isOwned } from "./immutable.js";
@@ -13,7 +14,7 @@ function measuredWidth(profile, text, style) {
     if (isOwned(profile)) measurementIndexes.set(profile, index);
   }
   return index.get(textMetricKey({ text, fontFamily: style.fontFamily ?? DEFAULT_FONT_FAMILY,
-    fontSize: style.fontSize, fontWeight: textMetricFontWeight(style.fontWeight) }));
+    fontSize: style.fontSize, fontWeight: textMetricFontWeight(style.fontWeight), fontStyle: style.fontStyle }));
 }
 
 function codePointWidth(codePoint) {
@@ -43,7 +44,7 @@ export function textBoundsFitCanvas(bounds, canvas) {
 
 export function measureTextWidth(
   text,
-  { fontSize, fontFamily, fontWeight } = {},
+  { fontSize, fontFamily, fontWeight, fontStyle } = {},
   profile
 ) {
   if (typeof text !== "string") {
@@ -52,7 +53,7 @@ export function measureTextWidth(
   if (!Number.isFinite(fontSize) || fontSize <= 0) {
     throw new RangeError("Text measurement requires a positive fontSize.");
   }
-  const measured = measuredWidth(profile, text, { fontSize, fontFamily, fontWeight });
+  const measured = measuredWidth(profile, text, { fontSize, fontFamily, fontWeight, fontStyle });
   if (measured !== undefined) return measured;
   let joined = false;
   let width = 0;
@@ -91,9 +92,11 @@ export function resolveTextBounds({
   x,
   y,
   text,
+  lines,
   fontSize,
   fontFamily,
   fontWeight,
+  fontStyle,
   textAlign = "left",
   textBaseline = "alphabetic",
   rotation = 0
@@ -101,7 +104,19 @@ export function resolveTextBounds({
   if (![x, y, rotation].every(Number.isFinite)) {
     throw new TypeError("Text bounds require finite x, y, and rotation values.");
   }
-  const width = measureTextWidth(text, { fontSize, fontFamily, fontWeight }, profile);
+  if (lines !== undefined) {
+    const cosine = Math.cos(rotation), sine = Math.sin(rotation);
+    const bounds = lines.map(line => resolveTextBounds({
+      x: x + line.x * cosine - line.y * sine, y: y + line.x * sine + line.y * cosine,
+      text: line.text, fontSize, fontFamily, fontWeight, fontStyle, textAlign, textBaseline, rotation
+    }, profile));
+    const union = bounds.reduce((result, bound) => ({
+      left: Math.min(result.left, bound.left), right: Math.max(result.right, bound.right),
+      top: Math.min(result.top, bound.top), bottom: Math.max(result.bottom, bound.bottom)
+    }), { left: Infinity, right: -Infinity, top: Infinity, bottom: -Infinity });
+    return Object.freeze(requireFiniteBounds(union, "Text"));
+  }
+  const width = measureTextWidth(text, { fontSize, fontFamily, fontWeight, fontStyle }, profile);
   const [left, right] = textAlign === "center"
     ? [-width / 2, width / 2]
     : ["right", "end"].includes(textAlign) ? [-width, 0] : [0, width];
@@ -126,3 +141,25 @@ export function resolveTextBounds({
   };
   return Object.freeze(requireFiniteBounds(bounds, "Text"));
 }
+
+export function unionBounds(bounds) {
+  return bounds.reduce((union, item) => ({
+    left: Math.min(union.left, item.left),
+    right: Math.max(union.right, item.right),
+    top: Math.min(union.top, item.top),
+    bottom: Math.max(union.bottom, item.bottom)
+  }), { left: Infinity, right: -Infinity, top: Infinity, bottom: -Infinity });
+}
+
+// Resolve explicit hard breaks once for text marks and guide layout.
+export function resolveTextLines(text, config) {
+  const parts = text.split(/\r\n|\r|\n/u);
+  if (parts.length === 1 && config.blockAlign !== "middle") return undefined;
+  validateGeneratedItemLimit(parts.length, "Text line count");
+  const lineHeight = config.lineHeight ?? config.fontSize * 1.2;
+  const bounds = resolveTextBounds({ x: 0, y: 0, text: "", fontSize: config.fontSize,
+    textBaseline: config.baseline, textAlign: config.align });
+  const offset = config.blockAlign === "middle"
+    ? -(bounds.top + bounds.bottom + (parts.length - 1) * lineHeight) / 2 : 0;
+  return parts.map((text, index) => ({ text, x: 0, y: offset + index * lineHeight }));
+}

package/src/core/validation.js

@@ -1,5 +1,6 @@
 import { annotateError } from "./diagnostics.js";
 import { isPlainObject } from "./immutable.js";
+import { getMarkGraphicTypes } from "./vocabulary.js";
 
 export const MAX_GENERATED_ITEMS = 10_000;
 export const MAX_WORK_ITEMS = 10_000_000;
@@ -30,6 +31,14 @@ export function validateWorkLimit(value, label) {
   return validateGeneratedItemLimit(value, label, MAX_WORK_ITEMS);
 }
 
+export function validateGraphicItemLimit(value, capacity) {
+  const point = capacity.pointOwned && getMarkGraphicTypes("point").includes(capacity.graphicType);
+  const label = point ? "Point mark item count" : capacity.label;
+  const maximum = point ? 50_000 : MAX_GENERATED_ITEMS;
+  if (point) validateGeneratedItemLimit(capacity.rawCount, label, maximum);
+  return validateGeneratedItemLimit(value, label, maximum);
+}
+
 export function validateKeys(value, supported, label) {
   for (const key of Object.keys(value)) {
     if (!supported.includes(key)) {
@@ -98,3 +107,29 @@ export function validateNonNegativeFinite(value, label) {
   }
   return value;
 }
+
+export function requireStringValue(value, label) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TypeError(`${label} must be a non-empty string.`);
+  }
+  return value;
+}
+
+export function rejectUnknownProperties(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 validateFontWeight(value, label, numberType = "number") {
+  if (typeof value !== "string" && !Number.isFinite(value)) {
+    throw new TypeError(`${label} must be a string or ${numberType}.`);
+  }
+  return value;
+}
+
+export function validateTextStyle(config, label) {
+  validateNonEmptyString(config.color, `${label} color`);
+  validatePositiveFinite(config.fontSize, `${label} fontSize`);
+  validateNonEmptyString(config.fontFamily, `${label} fontFamily`);
+  validateFontWeight(config.fontWeight, `${label} fontWeight`);
+}

package/src/core/vocabulary.js

@@ -220,6 +220,7 @@ export const LEGEND_CHANNELS = Object.freeze([
 ]);
 
 export const LEGEND_CONFIG_KINDS = Object.freeze([
+  "colorSize",
   "series",
   "color",
   "stroke",
@@ -235,3 +236,9 @@ export const LEGEND_CONFIG_KINDS = Object.freeze([
 export function includesVocabulary(vocabulary, value) {
   return vocabulary.includes(value);
 }
+
+export const PLOT_LEGEND_POSITIONS = Object.freeze(["top-left", "top-right", "bottom-left", "bottom-right"]);
+export const LEGEND_POSITIONS = Object.freeze(["left", "right", "top", "bottom", ...PLOT_LEGEND_POSITIONS]);
+export const LEGEND_BLOCK_LAYOUTS = Object.freeze(["row", "column", "wrap"]);
+
+export const AXIS_RESOURCE_CHANNELS = Object.freeze(["x", "y", "theta", "radius", "parallel"]);

package/src/grammar/aggregate.js

@@ -1,6 +1,8 @@
+import { requireStringValue as nonEmptyString } from "../core/validation.js";
+import { isGroupValue as isNominal } from "./transformKeys.js";
 import { isPlainObject } from "../core/immutable.js";
 import {
-  interpolateNumber,
+  quantileSorted,
   numericExtent,
   requireFiniteResult,
   stableFiniteDeviation,
@@ -25,11 +27,6 @@ const PARAMETERIZED_OPERATIONS = [
   "quantile", "first", "last", "ciLower", "ciUpper"
 ];
 
-function nonEmptyString(value, label) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string.`);
-  }
-}
 
 export function isScalarAggregate(value) {
   return typeof value === "string" && SCALAR_OPERATIONS.has(value);
@@ -137,10 +134,6 @@ function isMissing(value) {
     (typeof value === "number" && Number.isNaN(value));
 }
 
-function isNominal(value) {
-  return typeof value === "string" || typeof value === "boolean" ||
-    (typeof value === "number" && Number.isFinite(value));
-}
 
 export function validateAggregateFieldValues(rows, field, fieldType) {
   if (!Array.isArray(rows)) {
@@ -165,14 +158,7 @@ function finiteValues(values) {
 
 function quantile(values, probability) {
   const ordered = [...values].sort((left, right) => left - right);
-  const position = (ordered.length - 1) * probability;
-  const lower = Math.floor(position);
-  const upper = Math.ceil(position);
-  return interpolateNumber(
-    ordered[lower],
-    ordered[upper],
-    position - lower
-  );
+  return quantileSorted(ordered, probability);
 }
 
 function comparableOrderKey(value) {