ggaction 0.0.18 → 0.0.19

package/src/actions/theme/reconcile.js

@@ -1,3 +1,4 @@
+import { synchronizeFacetLegendAppearance } from "../../materialization/facetGuides/owner.js";
 import { rematerializeTypography } from "../../materialization/typography.js";
 import { AXIS_LABEL_FONT_SIZES, AXIS_TITLE_FONT_SIZE, themeTokens } from "../../theme/defaults.js";
 import {
@@ -182,7 +183,7 @@ function componentRole(program, id, property) {
 }
 
 function graphicRole(program, id, property) {
-  const axisPart = /Axis(Labels|Titles?)$/u.exec(id);
+  const axisPart = /(?:Axis|^axis_.+__)(Labels|Titles?)$/u.exec(id);
   const scoped = axisPart === null ? undefined : axisTextRole(property, axisPart[1] === "Labels" ? "labels" : "title");
   if (scoped !== undefined) return scoped;
   if (property === "fontFamily") return "fontFamily";
@@ -200,11 +201,11 @@ function graphicRole(program, id, property) {
     }
     return layer.mark?.type === "text" ? "text" : "mark";
   }
-  if (/AxisLines?$/u.test(id) && property === "stroke") return "axis";
-  if (/AxisTicks$/u.test(id) && property === "stroke") return "mutedText";
+  if (/(?:Axis|^axis_.+__)Lines?$/u.test(id) && property === "stroke") return "axis";
+  if (/(?:Axis|^axis_.+__)Ticks$/u.test(id) && property === "stroke") return "mutedText";
   if (/^parallelAxisLabels$/u.test(id) && property === "fill") return "axis";
-  if (/AxisLabels$/u.test(id) && property === "fill") return "text";
-  if (/AxisTitles?$/u.test(id) && property === "fill") return "axisTitle";
+  if (/(?:Axis|^axis_.+__)Labels$/u.test(id) && property === "fill") return "text";
+  if (/(?:Axis|^axis_.+__)Titles?$/u.test(id) && property === "fill") return "axisTitle";
   if (/Grid(?:Lines|Circles)?$/u.test(id) && property === "stroke") return "grid";
   if (id === "chartTitle" && property === "fill") return "strongText";
   if (id === "chartSubtitle" && property === "fill") return "mutedText";
@@ -676,12 +677,13 @@ function clearRemovedResources(overrides, node) {
       clearPrefix(overrides, `g:${mark[1]}.`);
       return;
     }
-    const axis = /^guide\.axis\.(x|y|theta|radius)$/u
+    const axis = /^guide\.axis\.([A-Za-z0-9_-]+)$/u
       .exec(current.args.property);
     if (axis !== null) {
       const prefix = axis[1] === "radius" ? "radial" : axis[1];
+      const graphicPrefix = ["x", "y", "theta", "radius"].includes(axis[1]) ? `${prefix}Axis` : `axis_${axis[1]}__`;
       clearPrefix(overrides, `c:guides.axis.${axis[1]}.`);
-      clearPrefix(overrides, `g:${prefix}Axis`);
+      clearPrefix(overrides, `g:${graphicPrefix}`);
       return;
     }
     const grid = /^guide\.grid\.([^\.]+)$/u.exec(current.args.property);
@@ -737,7 +739,23 @@ function clearRecreatedOverrides(overrides, op, args) {
   }
 }
 
-function addAxisOverrides(overrides, op, args) {
+function axisOverrideId(node, channel, args) {
+  if (args.target !== undefined || args.id !== undefined) return args.target ?? args.id;
+  const ids = new Set();
+  const visit = entry => {
+    if (["createGraphics", "editGraphics"].includes(entry.op)) {
+      const id = entry.args.target ?? entry.args.id;
+      const named = /^axis_(.+)__(Line|Ticks|Labels|Title)$/u.exec(id ?? "");
+      if (named !== null) ids.add(named[1]);
+      else if (new RegExp(`^${channel}Axis(?:Line|Ticks|Labels|Title)$`).test(id ?? "")) ids.add(channel);
+    }
+    entry.children?.forEach(visit);
+  };
+  if (node !== undefined) visit(node);
+  return ids.size === 1 ? [...ids][0] : channel;
+}
+
+function addAxisOverrides(overrides, op, args, node) {
   const match = /^(?:create|edit)(X|Y|Theta|Radial)Axis(Line|Ticks|Labels|Title)$/u
     .exec(op);
   if (match === null) return;
@@ -748,23 +766,25 @@ function addAxisOverrides(overrides, op, args) {
     Radial: "radius"
   }[match[1]];
   const component = match[2].toLowerCase();
+  const axisId = axisOverrideId(node, channel, args);
   const idPrefix = match[1] === "Radial" ? "radial" : channel;
   if (Object.hasOwn(args, "color")) {
-    overrides.add(`c:guides.axis.${channel}.${component}.color`);
+    overrides.add(`c:guides.axis.${axisId}.${component}.color`);
     overrides.add(
-      `g:${idPrefix}Axis${match[2]}.${component === "line" || component === "ticks" ? "stroke" : "fill"}`
+      `g:${axisId === channel ? `${idPrefix}Axis` : `axis_${axisId}__`}${match[2]}.${component === "line" || component === "ticks" ? "stroke" : "fill"}`
     );
   }
   for (const property of ["fontFamily", "fontSize"]) {
     if (["labels", "title"].includes(component) && Object.hasOwn(args, property)) {
-      overrides.add(`c:guides.axis.${channel}.${component}.${property}`);
-      overrides.add(`g:${idPrefix}Axis${match[2]}.${property}`);
+      overrides.add(`c:guides.axis.${axisId}.${component}.${property}`);
+      overrides.add(`g:${axisId === channel ? `${idPrefix}Axis` : `axis_${axisId}__`}${match[2]}.${property}`);
     }
   }
 }
 
-function addCompleteAxisOverride(overrides, name, args) {
+function addCompleteAxisOverride(overrides, name, args, node) {
   const channel = { X: "x", Y: "y", Theta: "theta", Radial: "radius" }[name];
+  const axisId = axisOverrideId(node, channel, args);
   const idPrefix = name === "Radial" ? "radial" : channel;
   const components = {
     line: args.line,
@@ -779,21 +799,21 @@ function addCompleteAxisOverride(overrides, name, args) {
   for (const [component, options] of Object.entries(components)) {
     const suffix = `${component[0].toUpperCase()}${component.slice(1)}`;
     if (Object.hasOwn(options ?? {}, "color")) {
-      overrides.add(`c:guides.axis.${channel}.${component}.color`);
+      overrides.add(`c:guides.axis.${axisId}.${component}.color`);
       overrides.add(
-        `g:${idPrefix}Axis${suffix}.${component === "line" || component === "ticks" ? "stroke" : "fill"}`
+        `g:${axisId === channel ? `${idPrefix}Axis` : `axis_${axisId}__`}${suffix}.${component === "line" || component === "ticks" ? "stroke" : "fill"}`
       );
     }
     for (const property of ["fontFamily", "fontSize"]) {
       if (["labels", "title"].includes(component) && Object.hasOwn(options ?? {}, property)) {
-        overrides.add(`c:guides.axis.${channel}.${component}.${property}`);
-        overrides.add(`g:${idPrefix}Axis${suffix}.${property}`);
+        overrides.add(`c:guides.axis.${axisId}.${component}.${property}`);
+        overrides.add(`g:${axisId === channel ? `${idPrefix}Axis` : `axis_${axisId}__`}${suffix}.${property}`);
       }
     }
   }
 }
 
-function addCompleteAxisOverrides(overrides, op, args) {
+function addCompleteAxisOverrides(overrides, op, args, node) {
   if (args.guides?.axes !== null && typeof args.guides?.axes === "object") {
     addCompleteAxisOverrides(overrides, "createAxes", args.guides.axes);
   }
@@ -801,10 +821,10 @@ function addCompleteAxisOverrides(overrides, op, args) {
     addCompleteAxisOverrides(overrides, "createAxes", args.axes);
   }
   const match = /^(?:create|edit)(X|Y|Theta|Radial)Axis$/u.exec(op);
-  if (match !== null) addCompleteAxisOverride(overrides, match[1], args);
+  if (match !== null) addCompleteAxisOverride(overrides, match[1], args, node);
   const group = /^(?:create|edit)(X|Y)AxisTicksAndLabels$/u.exec(op);
   if (group !== null) {
-    addCompleteAxisOverride(overrides, group[1], { ticksAndLabels: args });
+    addCompleteAxisOverride(overrides, group[1], { target: args.target, ticksAndLabels: args }, node);
   }
   if (op !== "createAxes") return;
   for (const [option, name] of [
@@ -814,7 +834,7 @@ function addCompleteAxisOverrides(overrides, op, args) {
     ["radius", "Radial"]
   ]) {
     if (args[option] && typeof args[option] === "object") {
-      addCompleteAxisOverride(overrides, name, args[option]);
+      for (const entry of Array.isArray(args[option]) ? args[option] : [args[option]]) addCompleteAxisOverride(overrides, name, entry);
     }
   }
 }
@@ -977,8 +997,8 @@ function explicitOverrides(program, node) {
   addErrorBarOverrides(overrides, program, node);
   addErrorBandOverrides(overrides, program, node);
   addRegressionOverrides(overrides, node);
-  addAxisOverrides(overrides, op, args);
-  addCompleteAxisOverrides(overrides, op, args);
+  addAxisOverrides(overrides, op, args, node);
+  addCompleteAxisOverrides(overrides, op, args, node);
   addGridOverrides(overrides, op, args);
   addParallelOverrides(overrides, program, op, args);
   if (["createTitle", "editTitle"].includes(op)) {
@@ -999,6 +1019,11 @@ function explicitOverrides(program, node) {
   if (op === "editLegendBlock") {
     addLegendBlockOverrides(overrides, program, args);
   }
+  const parentLegendOptions = op === "editFacetGuides" ? args.legend
+    : ["facet", "facetGrid", "repeatCharts"].includes(op) ? args.guides?.legend : undefined;
+  if (parentLegendOptions !== null && typeof parentLegendOptions === "object") {
+    addLegendOverrides(overrides, program, parentLegendOptions);
+  }
   if (op === "editFacetHeaders") {
     addFacetOverrides(overrides, program, args);
   }
@@ -1084,6 +1109,8 @@ export function reconcileProgramTheme(program, { source, metadata }) {
     next = next._withMaterializationConfig(["facets"], configs.value.facets);
   }
 
+  if (configs.changed) next = synchronizeFacetLegendAppearance(next);
+
   const facetsChanged = configs.value.facets !==
     themed.materializationConfigs.facets;
   const typographyChanged = sourceTokens.fontFamily !== targetTokens.fontFamily ||

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.'
     );
   }
 }

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/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
       ));
@@ -208,7 +208,7 @@ export function collectGuideConfigReferences(program) {
       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/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)) {

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",
@@ -239,3 +240,5 @@ export function includesVocabulary(vocabulary, 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/axisTextPlacement.js

@@ -0,0 +1 @@
+import{resolveTextLines as o}from"../core/textMetrics.js";function a(e,{title:i=!1}={}){if(Object.hasOwn(e,"align")&&!["left","center","right"].includes(e.align))throw new TypeError("Axis text align must be left, center, or right.");if(i){if(Object.hasOwn(e,"baseline")&&!["top","hanging","middle","alphabetic","ideographic","bottom"].includes(e.baseline))throw new TypeError("Axis title baseline must be a supported text baseline.");for(const t of["offset","alongOffset"])if(Object.hasOwn(e,t)&&!Number.isFinite(e[t]))throw new TypeError(`Axis title ${t} must be a finite number.`)}}function f(e,i){if(!/[\r\n]/u.test(e))return;const t=i.baseline??"middle",n=o(e,{fontSize:i.fontSize,align:i.align??"center",baseline:t,...t==="middle"?{blockAlign:"middle"}:{}});if(["bottom","ideographic"].includes(t)){const s=(n.length-1)*i.fontSize*1.2;return n.map(r=>({...r,y:r.y-s}))}return n.length>1?n:void 0}export{f as axisTitleTextLines,a as validateAxisTextPlacement};

package/src/grammar/colorSizeLegend.js

@@ -0,0 +1,39 @@
+import {sameOrderedValues,validateOptionObject,validateUnitInterval,validateNonNegativeFinite,validateNonEmptyString} from '../core/validation.js';
+import {isContinuousColorScaleType} from './scales/types.js';
+import {isContinuousSizeScaleType} from './scales/size.js';
+
+export function isColorSizeChannels(channels) {
+ return Array.isArray(channels)&&channels.length===2&&channels.includes('color')&&channels.includes('size');
+}
+
+export function resolveColorSizeMapping({layer,scales,pointConfig,coordinate}) {
+ const color=layer?.encoding?.color,size=layer?.encoding?.size;
+ const colorScale=scales[color?.scale],sizeScale=scales[size?.scale];
+ if(layer?.mark?.type!=='point'||coordinate?.type!=='cartesian'||
+   pointConfig?.shape!=='circle'||layer.encoding.shape!==undefined||
+   color?.fieldType!=='quantitative'||size?.fieldType!=='quantitative'||
+   typeof color.field!=='string'||color.field!==size.field||
+   color.aggregate!==size.aggregate||color.data!==size.data||
+   !isContinuousColorScaleType(colorScale?.type)||!isContinuousSizeScaleType(sizeScale?.type)) {
+  throw new Error('Color-size combination requires one Cartesian circle point owner with the same quantitative field and grain.');
+ }
+ const ends=scale=>[scale.domain?.[0],scale.domain?.at(-1)];
+ const domain=ends(colorScale),sizeDomain=ends(sizeScale);
+ if(!domain.every(Number.isFinite)||!sizeDomain.every(Number.isFinite)||
+   !sameOrderedValues(domain,sizeDomain)||domain[0]===domain[1]) {
+  throw new Error('Color-size combination requires identical finite numeric domain endpoints.');
+ }
+ return {target:layer.id,field:color.field,fieldType:'quantitative',colorScale:color.scale,sizeScale:size.scale,domain};
+}
+
+export function normalizeColorSizeSymbol(value,previous) {
+ if(value===undefined)return {...(previous??{type:'point',strokeWidth:0,opacity:1})};
+ if(value==='auto')return {type:'point',strokeWidth:0,opacity:1};
+ validateOptionObject(value,['type','stroke','strokeWidth','opacity'],'Color-size symbol');
+ if(value.type!==undefined&&value.type!=='point')throw new Error('Color-size symbols require type point.');
+ const symbol={type:'point',strokeWidth:0,opacity:1,...previous,...value};
+ if(symbol.stroke!==undefined)validateNonEmptyString(symbol.stroke,'Color-size symbol stroke');
+ validateNonNegativeFinite(symbol.strokeWidth,'Color-size symbol strokeWidth');
+ validateUnitInterval(symbol.opacity,'Color-size symbol opacity');
+ return symbol;
+}

package/src/grammar/computed.js

@@ -1,4 +1,5 @@
 import {parseTimeValue,validateParseTimeFormat} from "./parseTime.js";
+import { calendarParts, validateTimeZone } from "./timeUnit.js";
 import { rejectUnknownProperties as rejectUnknownKeys } from "../core/validation.js";
 import { requireStringValue as requireField } from "../core/validation.js";
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
@@ -6,7 +7,7 @@ import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
 const TRANSFORM_KEYS = Object.freeze(["type", "as", "expression"]);
 const ARITHMETIC_BINARY = new Set(["add", "subtract", "multiply", "divide"]);
 const COMPARISONS = new Set(["eq", "neq", "lt", "lte", "gt", "gte"]);
-const NUMERIC_UNARY = new Set(["negate", "absolute", "log", "sqrt"]);
+const NUMERIC_UNARY = new Set(["negate", "absolute", "log", "sqrt", "floor"]);
 const BOOLEAN_UNARY = new Set(["not", "isNull"]);
 const LOGICAL = new Set(["and", "or"]);
 const VARIADIC = new Set(["coalesce", "concat"]);
@@ -107,6 +108,14 @@ function inspectExpression(expression, depth, state, optionalPathRoot = false) {
       inspectExpression(expression.operand, depth + 1, state);
       return;
     }
+    if (expression.op === "datePart") {
+      rejectUnknownKeys(expression, ["op", "part", "operand", "timeZone"], "computed calendar expression");
+      requireNode(expression, "operand", expression.op);
+      if (expression.part !== "year") throw new Error("Computed datePart supports part year only.");
+      if (Object.hasOwn(expression, "timeZone")) validateTimeZone(expression.timeZone);
+      inspectExpression(expression.operand, depth + 1, state);
+      return;
+    }
     if (expression.op === "parseTime") {
       rejectUnknownKeys(expression, ["op", "operand", "format"], "computed time expression");
       requireNode(expression, "operand", expression.op);
@@ -339,6 +348,18 @@ function evaluate(expression, row, rowIndex) {
       ? value === null
       : !boolean(value, operation, rowIndex);
   }
+  if (operation === "datePart") {
+    const value = evaluate(expression.operand, row, rowIndex);
+    if (value === null) return null;
+    number(value, operation, rowIndex);
+    if (Math.abs(value) > 8_640_000_000_000_000) {
+      throw new RangeError(`Computed datePart timestamp is outside the supported Date range at row ${rowIndex}.`);
+    }
+    const timestamp = new Date(value).getTime();
+    return (expression.timeZone ?? "UTC") === "UTC"
+      ? new Date(timestamp).getUTCFullYear()
+      : calendarParts(timestamp, expression.timeZone).year;
+  }
   if (operation === "parseTime") {
     return parseTimeValue(evaluate(expression.operand, row, rowIndex), expression.format);
   }
@@ -360,6 +381,7 @@ function evaluate(expression, row, rowIndex) {
     }
     const result = operation === "negate" ? -value
       : operation === "absolute" ? Math.abs(value)
+        : operation === "floor" ? Math.floor(value)
         : operation === "log" ? Math.log(value)
           : Math.sqrt(value);
     if (!Number.isFinite(result)) {

package/src/grammar/datasetSchema.js

@@ -1,6 +1,7 @@
 import { requireStringValue as requireName } from "../core/validation.js";
 import { annotateError } from "../core/diagnostics.js";
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
+import { requireRegressionStatisticsSource, REGRESSION_STATISTIC_FIELDS } from "./regression/statistics.js";
 
 const STORAGE_TYPES = new Set([
   "number", "string", "boolean", "array", "object", "unknown", "mixed"
@@ -267,7 +268,7 @@ function generatedField(name, storageType, transform, role, inputs = []) {
   };
 }
 
-export function deriveTransformSchema(inputSchema, transform, values, { sourceId, ownerId } = {}) {
+export function deriveTransformSchema(inputSchema, transform, values, { sourceId, ownerId, sourceTransform } = {}) {
   const input = validateDatasetSchema(inputSchema);
   const definition = { ...transform, __sourceId: sourceId, __ownerId: ownerId };
   const retain = ["filter", "markFilter", "sort", "computed", "timeUnit", "window", "normalize", "stack", "impute", "complete"];
@@ -300,6 +301,12 @@ export function deriveTransformSchema(inputSchema, transform, values, { sourceId
       generatedField(transform.as.count, "number", definition, "count", [transform.x, transform.y])
     ];
     if (transform.as.members !== undefined) push(generatedField(transform.as.members, "array", definition, "members"));
+  } else if (transform.type === "regressionStatistics") {
+    const fit = requireRegressionStatisticsSource({ transform: sourceTransform === undefined ? [] : [sourceTransform] });
+    fields = [
+      ...(fit.groupBy === undefined ? [] : [inheritedField(input, fit.groupBy)]),
+      ...REGRESSION_STATISTIC_FIELDS.map(name => generatedField(name, "number", definition, name))
+    ].filter(Boolean);
   } else if (transform.type === "regression") {
     fields = [inheritedField(input, transform.x), inheritedField(input, transform.y)].filter(Boolean);
     if (transform.groupBy !== undefined) fields.unshift(inheritedField(input, transform.groupBy));
@@ -367,7 +374,8 @@ export function deriveTransformSchema(inputSchema, transform, values, { sourceId
       if (planned.lineage === undefined && !["complete", "impute"].includes(transform.type)) {
         return planned;
       }
-      return { ...planned, storageType: field.storageType, nullable: field.nullable, optional: field.optional };
+      return { ...planned, storageType: transform.type === "regressionStatistics" && planned.storageType === "number"
+        ? "number" : field.storageType, nullable: field.nullable, optional: field.optional };
     });
     for (const field of inferred.fields) {
       if (!fields.some(planned => planned.name === field.name)) fields.push(field);

package/src/grammar/displayLabels.js

@@ -44,6 +44,14 @@ export function normalizeDisplayLabelMap(value, label = "labelMap") {
   return Object.freeze(normalized);
 }
 
+export function normalizeNumericDisplayLabelMap(value, label = "labelMap") {
+  const map = normalizeDisplayLabelMap(value, label);
+  if (map.some(entry => typeof entry.value !== "number" || !Number.isFinite(entry.value))) {
+    throw new TypeError(`${label} values must be finite numbers.`);
+  }
+  return map;
+}
+
 export function resolveDisplayLabel(value, map, fallback) {
   if (map !== undefined) {
     for (const entry of map) {

package/src/grammar/facets/guides.js

@@ -3,13 +3,15 @@ import { cloneAndFreeze, isPlainObject } from "../../core/immutable.js";
 const LEGEND_FAMILIES = Object.freeze({
   series: "categorical",
   color: "categorical",
+  colorSize: "color-size",
   stroke: "categorical",
   gradient: "gradient",
   interval: "discretized",
   strokeGradient: "gradient",
   strokeInterval: "discretized",
   size: "size",
-  opacity: "opacity"
+  opacity: "opacity",
+  strokeWidth: "stroke-width"
 });
 
 function requirePlacements(placements) {
@@ -72,25 +74,34 @@ function translatedBounds(placement, bounds, channel) {
   };
 }
 
+export function resolveFacetOuterSides({ placements } = {}) {
+  const cells = requirePlacements(placements);
+  const edges = { top: new Map(), bottom: new Map(), left: new Map(), right: new Map() };
+  for (const cell of cells) {
+    for (const [side, key, coordinate, better] of [
+      ["top", cell.column, "row", (a, b) => a < b],
+      ["bottom", cell.column, "row", (a, b) => a > b],
+      ["left", cell.row, "column", (a, b) => a < b],
+      ["right", cell.row, "column", (a, b) => a > b]
+    ]) {
+      const previous = edges[side].get(key);
+      if (previous === undefined || better(cell[coordinate], previous[coordinate])) edges[side].set(key, cell);
+    }
+  }
+  return cloneAndFreeze(Object.fromEntries(Object.entries(edges).map(([side, owners]) => {
+    const ids = new Set([...owners.values()].map(cell => cell.id));
+    return [side, cells.filter(cell => ids.has(cell.id)).map(cell => cell.id)];
+  })));
+}
+
 export function resolveFacetOuterAxes({ placements, axisBounds = {} } = {}) {
   const cells = requirePlacements(placements);
   if (!isPlainObject(axisBounds)) {
     throw new TypeError("Facet axisBounds must be a plain object.");
   }
-  const bottomByColumn = new Map();
-  const leftByRow = new Map();
-  for (const cell of cells) {
-    const bottom = bottomByColumn.get(cell.column);
-    if (bottom === undefined || cell.row > bottom.row) {
-      bottomByColumn.set(cell.column, cell);
-    }
-    const left = leftByRow.get(cell.row);
-    if (left === undefined || cell.column < left.column) {
-      leftByRow.set(cell.row, cell);
-    }
-  }
-  const xOwners = new Set([...bottomByColumn.values()].map(cell => cell.id));
-  const yOwners = new Set([...leftByRow.values()].map(cell => cell.id));
+  const sides = resolveFacetOuterSides({ placements: cells });
+  const xOwners = new Set(sides.bottom);
+  const yOwners = new Set(sides.left);
   return cloneAndFreeze({
     x: cells.filter(cell => xOwners.has(cell.id)).map(cell => cell.id),
     y: cells.filter(cell => yOwners.has(cell.id)).map(cell => cell.id),
@@ -129,7 +140,7 @@ function comparableConfig(config) {
   return stableValue(rest);
 }
 
-function sameValue(left, right) {
+export function sameFacetGuideValue(left, right) {
   return JSON.stringify(stableValue(left)) === JSON.stringify(stableValue(right));
 }
 
@@ -152,12 +163,13 @@ function requireLegendChildren(children) {
   });
 }
 
-function scaleIds(config) {
-  const ids = config.scales ?? (config.scale === undefined ? [] : [config.scale]);
+function scaleIds(config, kind) {
+  const ids = kind === "colorSize" ? [config.colorScale, config.sizeScale]
+    : config.scales ?? (config.scale === undefined ? [] : [config.scale]);
   if (!Array.isArray(ids) || ids.length === 0 || !ids.every(id =>
     typeof id === "string" && id.length > 0
   )) {
-    throw new Error(`Shared ${config.kind} legend requires resolved scale ids.`);
+    throw new Error(`Shared ${kind} legend requires resolved scale ids.`);
   }
   return ids;
 }
@@ -166,7 +178,7 @@ export function resolveSharedFacetLegends(children) {
   const normalized = requireLegendChildren(children);
   const first = normalized[0];
   for (const child of normalized.slice(1)) {
-    if (!sameValue(first.guideConfigs.legendGroups, child.guideConfigs.legendGroups)) {
+    if (!sameFacetGuideValue(first.guideConfigs.legendGroups, child.guideConfigs.legendGroups)) {
       throw new Error(`Facet child "${child.id}" has incompatible legend group placement.`);
     }
   }
@@ -183,7 +195,7 @@ export function resolveSharedFacetLegends(children) {
     ) {
       throw new Error(`Facet child "${first.id}" has invalid ${kind} legend config.`);
     }
-    const scales = scaleIds(config);
+    const scales = scaleIds(config, kind);
     const resolvedScales = Object.fromEntries(scales.map(id => {
       const scale = first.resolvedScales[id];
       if (!isPlainObject(scale)) {
@@ -195,14 +207,14 @@ export function resolveSharedFacetLegends(children) {
       const candidate = child.legends[kind];
       if (
         !isPlainObject(candidate) ||
-        !sameValue(comparableConfig(config), comparableConfig(candidate))
+        !sameFacetGuideValue(comparableConfig(config), comparableConfig(candidate))
       ) {
         throw new Error(
           `Facet child "${child.id}" has an incompatible ${kind} legend config.`
         );
       }
       for (const id of scales) {
-        if (!sameValue(resolvedScales[id], child.resolvedScales[id])) {
+        if (!sameFacetGuideValue(resolvedScales[id], child.resolvedScales[id])) {
           throw new Error(
             `Facet child "${child.id}" has an incompatible resolved legend scale "${id}".`
           );
@@ -213,7 +225,7 @@ export function resolveSharedFacetLegends(children) {
   });
   for (const child of normalized.slice(1)) {
     const childKinds = Object.keys(child.legends);
-    if (!sameValue([...kinds].sort(), [...childKinds].sort())) {
+    if (!sameFacetGuideValue([...kinds].sort(), [...childKinds].sort())) {
       throw new Error(`Facet child "${child.id}" has incompatible legend kinds.`);
     }
   }
@@ -234,7 +246,7 @@ export function planFacetGuideOwnership({
   if (!["each", "outer"].includes(axes)) {
     throw new Error("Facet axes must be each or outer.");
   }
-  if (![false, "shared"].includes(legend)) {
+  if (![false, "shared"].includes(legend) && !isPlainObject(legend)) {
     throw new Error("Facet legend must be false or shared.");
   }
   const byId = new Map(children.map(child => [child.id, child]));
@@ -242,23 +254,34 @@ export function planFacetGuideOwnership({
     throw new Error("Facet guide child ids must match occupied placements exactly.");
   }
   const outer = resolveFacetOuterAxes({ placements: cells });
-  if (legend === "shared" && !isPlainObject(sharedLegends)) {
+  const sides = resolveFacetOuterSides({ placements: cells });
+  if (legend !== false && !isPlainObject(sharedLegends)) {
     throw new Error("Shared facet legend ownership requires a compatibility plan.");
   }
   return cloneAndFreeze({
     children: Object.fromEntries(cells.map(cell => {
       const descriptor = byId.get(cell.id);
       const presentAxes = descriptor.axes ?? [];
-      const keepAxes = axes === "each"
-        ? presentAxes
-        : presentAxes.filter(channel => outer.children[cell.id][channel]);
+      const records = descriptor.axisOwners;
+      const removed = {};
+      const keepAxes = axes === "each" ? presentAxes : records === undefined
+        ? presentAxes.filter(channel => outer.children[cell.id][channel])
+        : presentAxes.filter(id => {
+          const owner = records.find(owner => owner.id === id);
+          if (owner === undefined) throw new Error("Facet axis descriptors must identify every retained owner.");
+          const components = Object.entries(owner.components);
+          const remove = components.filter(([, side]) => !sides[side]?.includes(cell.id)).map(([component]) => component);
+          if (remove.length > 0 && remove.length < components.length) removed[id] = remove;
+          return remove.length < components.length;
+        });
       return [cell.id, {
         keepAxes,
         removeAxes: presentAxes.filter(channel => !keepAxes.includes(channel)),
-        removeLegends: legend === "shared" ? descriptor.legendKinds ?? [] : []
+        ...(records === undefined ? {} : { removeAxisComponents: removed }),
+        removeLegends: legend !== false ? descriptor.legendKinds ?? [] : []
       }];
     })),
-    parent: legend === "shared"
+    parent: legend !== false
       ? { legends: sharedLegends.entries, promoteFrom: sharedLegends.source }
       : { legends: [] }
   });