ggaction 0.0.18 → 0.0.20

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: [] }
   });

package/src/grammar/facets/legendIntent.js

@@ -0,0 +1,65 @@
+import { isPlainObject } from "../../core/immutable.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";
+
+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",
+  "count", "sampling", "representation", "gradientDirection", "inheritAppearance", "inheritPosition", "blockOverrides",
+  "combine", "sizeAreas", "clipHeight"
+]);
+
+export function isAuthoredFacetLegend(value) {
+  return isPlainObject(value) && value.type === "authored-legend";
+}
+
+export function validateAuthoredFacetLegend(program, intent) {
+  validateOptionObject(intent, ["type", "blocks", "groups"], "Stored parent legend");
+  if (!isAuthoredFacetLegend(intent) || Object.keys(intent).length !== 3 ||
+      !isPlainObject(intent.blocks) || Object.keys(intent.blocks).length === 0 || !isPlainObject(intent.groups)) {
+    throw new Error("Stored parent legend requires its closed authored block intent.");
+  }
+  validateLegendGroupState(intent.groups);
+  const configs = {};
+  for (const [kind, block] of Object.entries(intent.blocks)) {
+    if (!LEGEND_CONFIG_KINDS.includes(kind)) throw new Error("Stored parent legend has an unknown block kind.");
+    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;
+    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"]) {
+      if (config[flag] !== undefined && typeof config[flag] !== "boolean") throw new Error(`Stored parent legend ${flag} must be boolean.`);
+    }
+    const descriptor = describeLegendBlock(program, kind, config);
+    if (block.guide !== undefined) {
+      validateOptionObject(block.guide, kind === "colorSize" ? ["colorScale", "sizeScale", "title"]
+        : ["scale", "scales", "channels", "title", "order"], "Stored parent legend meaning");
+      if (kind === "colorSize" && (block.guide.colorScale !== config.colorScale || block.guide.sizeScale !== config.sizeScale)) {
+        throw new Error("Stored parent color-size meaning must match both block scale bindings.");
+      }
+      if (block.guide.title !== undefined) validateNonEmptyString(block.guide.title, "Parent legend title");
+      if (block.guide.channels !== undefined && !same([...block.guide.channels].sort(), descriptor.channels)) {
+        throw new Error("Stored parent legend meaning must match its block channels.");
+      }
+      if (block.guide.scale !== undefined && block.guide.scale !== descriptor.scaleIds[0] ||
+          block.guide.scales !== undefined && !same(block.guide.scales, descriptor.scaleIds)) {
+        throw new Error("Stored parent legend meaning must match its block scale binding.");
+      }
+    }
+    if (!same(config, program.guideConfigs.legend?.[kind])) throw new Error("Parent legend materialization must match its authored owner.");
+    configs[kind] = config;
+  }
+  if (!same(Object.keys(configs).sort(), Object.keys(program.guideConfigs.legend ?? {}).sort()) ||
+      !same(intent.groups, program.guideConfigs.legendGroups ?? {})) {
+    throw new Error("Parent legend materialization must contain exactly its authored blocks and groups.");
+  }
+  resolveSharedFacetLegends(program.compositionSpec.children.map(id => ({ id,
+    guideConfigs: { legend: configs, legendGroups: intent.groups }, resolvedScales: program.children[id].resolvedScales })));
+  return intent;
+}

package/src/grammar/guideDash.js

@@ -0,0 +1 @@
+import{isPlainObject as i}from"../core/immutable.js";import{validateGeneratedItemLimit as o}from"../core/validation.js";function n(e,s="Guide strokeDash"){if(!Array.isArray(e)||e.length%2!==0||!e.every(r=>Number.isFinite(r)&&r>=0))throw new TypeError(`${s} must be an even-length array of non-negative finite numbers.`);return o(e.length,s),e}function u(e,{reset:s=!0}={}){if(e==="auto"&&s)return;if(!Array.isArray(e))throw new TypeError("Guide strokeDashMap must be an array.");o(e.length,"Guide strokeDashMap count");const r=new Set,a=e.map(t=>{if(!i(t)||Reflect.ownKeys(t).length!==2||!Object.hasOwn(t,"value")||!Object.hasOwn(t,"strokeDash"))throw new TypeError("Guide strokeDashMap entries must contain exactly value and strokeDash.");if(!["string","boolean"].includes(typeof t.value)&&!Number.isFinite(t.value))throw new TypeError("Guide strokeDashMap values must be strings, booleans, or finite numbers.");if(r.has(t.value))throw new Error("Guide strokeDashMap contains a duplicate typed value.");return r.add(t.value),n(t.strokeDash),Object.freeze({value:t.value,strokeDash:Object.freeze([...t.strokeDash])})});return a.length===0?void 0:Object.freeze(a)}function d(e,s){const r={...e};if(Object.hasOwn(s,"strokeDash")&&(n(s.strokeDash),r.strokeDash=[...s.strokeDash]),Object.hasOwn(s,"strokeDashMap")){const a=u(s.strokeDashMap);a===void 0?delete r.strokeDashMap:r.strokeDashMap=a}return r}function D(e,s){const r=new Map(s.strokeDashMap?.map(a=>[a.value,a.strokeDash]));return e.map(a=>r.get(a)??s.strokeDash??[])}export{u as normalizeGuideDashMap,d as patchGuideDash,D as resolveGuideDashes,n as validateGuideDash};

package/src/grammar/interval.js

@@ -4,6 +4,9 @@ import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
 import { aggregateScalarValues } from "./aggregate.js";
 import { requireFiniteResult, stableDecimal } from "./numeric.js";
 import {
+  createBootstrapMeanSampler,
+  bootstrapMeanBounds,
+  validateBootstrapDrawCount,
   confidenceCriticalValue,
   normalizeConfidenceInterval
 } from "./statistics/confidenceInterval.js";
@@ -91,7 +94,8 @@ export function validateIntervalTransform(transform) {
   if (transform.extent === "ci") {
     normalizeConfidenceInterval(transform, {
       defaultMethod: "student-t",
-      label: "Interval CI"
+      label: "Interval CI",
+      allowBootstrap: true
     });
   } else if (transform.method !== undefined) {
     throw new Error("Interval method is supported only for ci extent.");
@@ -117,11 +121,12 @@ export function normalizeIntervalParameters({
   extent = "ci",
   method,
   level
-} = {}) {
+} = {}, { allowBootstrap = false } = {}) {
   const confidence = extent === "ci"
     ? normalizeConfidenceInterval({ method, level }, {
         defaultMethod: "student-t",
-        label: "Interval CI"
+        label: "Interval CI",
+        allowBootstrap
       })
     : undefined;
   const candidate = {
@@ -164,7 +169,11 @@ function isMissing(value) {
 }
 
 
-function deriveGroup(values, transform) {
+function deriveGroup(values, transform, bootstrapSampler) {
+  if (bootstrapSampler !== undefined) {
+    const bounds = bootstrapMeanBounds(bootstrapSampler(values), transform.level);
+    return bounds === undefined ? undefined : { center: aggregateScalarValues(values, "mean"), ...bounds };
+  }
   if (transform.center === "median") {
     if (values.length === 0) return undefined;
     return {
@@ -235,9 +244,16 @@ export function deriveInterval(rows, transform) {
     groups.get(key).values.push(value);
   }
 
+  const bootstrapMethod = transform.method?.type === "bootstrap"
+    ? normalizeConfidenceInterval(transform, { defaultMethod: "student-t", allowBootstrap: true }).method : undefined;
+  if (bootstrapMethod !== undefined) {
+    validateBootstrapDrawCount(bootstrapMethod.samples * [...groups.values()].reduce((count, group) => count + group.values.length, 0));
+  }
+  const bootstrapSampler = bootstrapMethod === undefined ? undefined : createBootstrapMeanSampler(bootstrapMethod);
+
   const output = [];
   for (const group of groups.values()) {
-    const result = deriveGroup(group.values, transform);
+    const result = deriveGroup(group.values, transform, bootstrapSampler);
     if (result === undefined) continue;
     output.push({
       ...group.fields,
@@ -277,7 +293,7 @@ export function normalizeIntervalTransform({
 }) {
   nonEmptyString(field, "Interval field");
   const grouping = normalizeGrouping(groupBy);
-  const parameters = normalizeIntervalParameters({ center, extent, method, level });
+  const parameters = normalizeIntervalParameters({ center, extent, method, level }, { allowBootstrap: true });
   const transform = {
     type: "interval",
     field,

package/src/grammar/legendBlocks.js

@@ -0,0 +1 @@
+import{LEGEND_CHANNELS as d,LEGEND_CONFIG_KINDS as h}from"../core/vocabulary.js";import{isEnumeratedSizeScaleType as u}from"./scales/size.js";function y(e,r){if(!Array.isArray(e))throw new TypeError(`${r} channels must be an array.`);if(e.length===0)throw new Error(`${r} channels must select at least one channel.`);const s=new Set;for(const t of e){if(!d.includes(t))throw new Error(`Unsupported legend channel "${t}".`);if(s.has(t))throw new Error(`${r} channels contains duplicate "${t}".`);s.add(t)}}const o=Object.freeze(["series","color","stroke"]),a=Object.freeze({size:"size",opacity:"opacity",strokeWidth:"strokeWidth",gradient:"color",interval:"color",strokeGradient:"stroke",strokeInterval:"stroke"}),c=(e,r)=>e<r?-1:e>r?1:0;function w(e,r){const s=e==="colorSize"?["color","size"]:o.includes(e)?r?.channels:a[e]===void 0?void 0:[a[e]];if(!Array.isArray(s)||s.length===0)throw new Error(`Legend block ${e} requires at least one channel.`);return y(s,`Legend block ${e}`),Object.freeze([...s].sort(c))}function p(e){if(!Array.isArray(e)||e.length===0)throw new TypeError("Legend block key requires a non-empty channel array.");return JSON.stringify([...e].sort(c))}function b(e,r,s){if(!h.includes(r))throw new Error(`Unknown legend block kind "${r}".`);const t=w(r,s),n=r==="colorSize"?[s.colorScale,s.sizeScale]:o.includes(r)?s?.scales:[s?.scale];if(!Array.isArray(n)||n.length===0||n.some(l=>typeof l!="string"||e.resolvedScales[l]===void 0))throw new Error(`Legend block ${r} requires resolved scales.`);const i=o.includes(r)?"categorical":r==="colorSize"?"sampled":r==="size"?u(e.resolvedScales[n[0]].type)?"discrete-size":"sampled":["opacity","strokeWidth"].includes(r)||r==="gradient"&&s.representation==="symbols"?"sampled":["gradient","strokeGradient"].includes(r)?"gradient":"interval";return Object.freeze({target:s.target,kind:r,family:i,key:p(t),channels:t,scaleIds:Object.freeze([...n]),config:s})}function g(e,r){return e.symbol.layers.length===1&&(e.kind==="series"&&r==="line"||["color","stroke"].includes(e.kind)&&r==="swatch")?`${e.kind}LegendSymbols`:`${e.kind}LegendSymbol${{line:"Lines",point:"Points",swatch:"Swatches"}[r]}`}export{g as categoricalLegendSymbolId,b as describeLegendBlock,w as legendBlockChannels,p as legendBlockKey,y as validateLegendChannels};

package/src/grammar/legendBorder.js

@@ -0,0 +1,9 @@
+// Legend borders use one closed rectangular path, so odd dash duplication is not implicit.
+export function normalizeLegendBorderDash(value, label = "Legend border strokeDash") {
+  if (value === undefined) return undefined;
+  if (!Array.isArray(value) || value.length % 2 !== 0 ||
+      ![...value].every(item => Number.isFinite(item) && item >= 0)) {
+    throw new TypeError(`${label} must be an even-length array of non-negative finite numbers.`);
+  }
+  return Object.freeze([...value]);
+}

package/src/grammar/legendClip.js

@@ -0,0 +1,19 @@
+export function normalizeLegendClipHeight(value,{edit=false}={}){
+ if(value===undefined||edit&&value==='auto')return undefined;
+ if(!Number.isFinite(value)||value<=0)throw new RangeError('Legend clipHeight must be a positive finite number.');
+ return value;
+}
+export function validateLegendClip(kind,config){
+ if(config.clipHeight===undefined)return;
+ normalizeLegendClipHeight(config.clipHeight);
+ const supported=['size','opacity','colorSize'].includes(kind)||kind==='gradient'&&config.representation==='symbols'||
+  ['series','color','stroke'].includes(kind)&&config.symbol?.layers?.some(layer=>layer.type==='point');
+ if(!supported)throw new Error('Legend clipHeight requires a point-bearing sample block.');
+}
+export function patchLegendClipHeight(config,value){
+ const {clipHeight:_old,...rest}=config,clipHeight=normalizeLegendClipHeight(value,{edit:true});
+ return clipHeight===undefined?rest:{...rest,clipHeight};
+}
+export function clippedSampleBounds(bounds,height){
+ return height===undefined?bounds:{...bounds,top:Math.max(bounds.top,-height/2),bottom:Math.min(bounds.bottom,height/2)};
+}

package/src/grammar/legendCombinations.js

@@ -0,0 +1,45 @@
+import { sameOrderedValues, validateGeneratedItemLimit } from "../core/validation.js";
+import { mapOrdinalValues } from "./scales/index.js";
+import { readNominalField } from "./scales/fields.js";
+import { resolveLegendOrderDomain } from "./categoryOrder.js";
+
+export function isSizeShapeChannels(channels) {
+  return Array.isArray(channels) && channels.length === 2 &&
+    channels.includes('shape') && channels.includes('size');
+}
+export function validateLegendCombine(value) {
+  if(value===undefined)return;
+  if (!['separate','size-shape','color-size'].includes(value)) throw new Error('Legend combine must be separate, size-shape, or color-size.');
+}
+export function validateMappedSizeShapeSymbol(symbol) {
+  if(symbol===undefined||symbol==='auto')return;
+  const layers=symbol.layers??[];
+  if(layers.some(layer=>layer.type==='point'&&(Object.hasOwn(layer,'shape')||Object.hasOwn(layer,'size')))) {
+    throw new Error('Combined size-shape symbols cannot override mapped shape or size.');
+  }
+}
+
+export function resolveSizeShapeMapping({layer,scales,order,rows}) {
+  const shape=layer?.encoding?.shape,size=layer?.encoding?.size;
+  const shapeScale=scales[shape?.scale],sizeScale=scales[size?.scale];
+  if(layer?.mark?.type!=="point"||shape?.field!==size?.field||
+      !["nominal","ordinal"].includes(size?.fieldType)||shapeScale?.type!=="ordinal"||
+      sizeScale?.type!=="ordinal"||!sameOrderedValues(shapeScale.domain,sizeScale.domain)) {
+    throw new Error("Combined size-shape requires one categorical point field and identical ordered domains.");
+  }
+  validateGeneratedItemLimit(shapeScale.domain.length,"Categorical legend item count");
+  if(shapeScale.domain.length===0||sizeScale.range.some(area=>!Number.isFinite(area)||area<0)) {
+    throw new Error("Combined size-shape requires a nonempty domain and finite nonnegative areas.");
+  }
+  let linked;
+  if(order?.channel!==undefined){
+    const position=layer.encoding[order.channel];
+    if(!["nominal","ordinal"].includes(position?.fieldType)||position.field!==shape.field) {
+      throw new Error("Linked legend order requires the same categorical field on its target.");
+    }
+    linked=scales[position.scale]?.domain;
+  }
+  const domain=resolveLegendOrderDomain(shapeScale.domain,order,linked,
+    order?.values===undefined?undefined:readNominalField(rows,shape.field));
+  return {domain,sizeAreas:mapOrdinalValues(domain,sizeScale.domain,sizeScale.range)};
+}

package/src/grammar/legendGradient.js

@@ -16,3 +16,12 @@ export function normalizeLegendGradient(patch, previous = DEFAULT_LEGEND_GRADIEN
   validateLegendGradient(value);
   return value;
 }
+
+
+export function normalizeGradientDirection(value, label = "Gradient legend direction") {
+  if (value === undefined) return undefined;
+  if (value !== "horizontal" && value !== "vertical") {
+    throw new Error(`${label} must be horizontal or vertical.`);
+  }
+  return value;
+}

package/src/grammar/legendGroups.js

@@ -1 +1 @@
-import{validateOptionObject as r,validateNonNegativeFinite as i}from"../core/validation.js";import{validateUserId as a}from"../core/identifiers.js";import{PLOT_LEGEND_POSITIONS as g,LEGEND_POSITIONS as d,LEGEND_BLOCK_LAYOUTS as f}from"../core/vocabulary.js";function s(n){r(n,void 0,"Legend groups");for(const[o,t]of Object.entries(n)){if(a(o,"Legend group target"),r(t,["placement","blockLayout","inferredOffset"],"Legend group"),!f.includes(t.blockLayout))throw new Error("Legend group blockLayout must be row, column or wrap.");if(t.inferredOffset!==void 0&&typeof t.inferredOffset!="boolean")throw new TypeError("Legend group inferredOffset must be boolean.");const e=t.placement;if(r(e,["at","position","align","offset"],"Legend group placement"),Object.hasOwn(e,"at")){if(Object.keys(e).length!==1)throw new Error("Legend group at cannot coexist with an edge anchor.");if(r(e.at,["x","y"],"Legend group at"),!Number.isFinite(e.at.x)||!Number.isFinite(e.at.y))throw new Error("Legend group at requires finite x and y.")}else{if(Object.keys(e).length!==3||!d.includes(e.position))throw new Error("Legend group requires a complete edge placement.");if(!["left","center","right"].includes(e.align))throw new Error("Unsupported legend group alignment.");if((g.includes(e.position)||["left","right"].includes(e.position))&&e.align!=="center")throw new Error("Side and in-plot legend groups require center alignment.");i(e.offset,"Legend group offset")}}return n}export{s as validateLegendGroupState};
+import{validateOptionObject as o,validateNonNegativeFinite as d}from"../core/validation.js";import{validateUserId as l}from"../core/identifiers.js";import{PLOT_LEGEND_POSITIONS as i,LEGEND_POSITIONS as a,LEGEND_BLOCK_LAYOUTS as f}from"../core/vocabulary.js";function c(n){o(n,void 0,"Legend groups");for(const[t,r]of Object.entries(n)){if(l(t,"Legend group target"),o(r,["placement","blockLayout","inferredOffset"],"Legend group"),!f.includes(r.blockLayout))throw new Error("Legend group blockLayout must be row, column or wrap.");if(r.inferredOffset!==void 0&&typeof r.inferredOffset!="boolean")throw new TypeError("Legend group inferredOffset must be boolean.");const e=r.placement;if(o(e,["at","position","align","offset"],"Legend group placement"),Object.hasOwn(e,"at")){if(Object.keys(e).length!==1)throw new Error("Legend group at cannot coexist with an edge anchor.");if(o(e.at,["x","y"],"Legend group at"),!Number.isFinite(e.at.x)||!Number.isFinite(e.at.y))throw new Error("Legend group at requires finite x and y.")}else{if(Object.keys(e).length!==3||!a.includes(e.position))throw new Error("Legend group requires a complete edge placement.");if(!["left","center","right"].includes(e.align))throw new Error("Unsupported legend group alignment.");if((i.includes(e.position)||["left","right"].includes(e.position))&&e.align!=="center")throw new Error("Side and in-plot legend groups require center alignment.");d(e.offset,"Legend group offset")}}return n}function s(n){const t=Object.values(n?.blockOverrides??{}).map(r=>r.position).filter(r=>r!==void 0);if(t.length>1)throw new Error("Legend family has ambiguous local positions.");if(t.length&&!a.includes(t[0]))throw new Error("Invalid local legend position.");return t[0]}function m(n){const t=s(n);if(t!==void 0)return{position:t,align:["top","bottom"].includes(t)?n.align??"center":"center",offset:i.includes(t)?8:n.offset??(n.channels===void 0?30:8),inferredOffset:n.inferredOffset??!0}}export{m as localLegendPlacement,s as localLegendPosition,c as validateLegendGroupState};

package/src/grammar/legendOpacity.js

@@ -0,0 +1,6 @@
+export function validateLegendLayerOpacity(value) {
+  if(value!==undefined&&(!Number.isFinite(value)||value<0||value>1)) {
+    throw new RangeError("Legend symbol layer opacity must be finite and between 0 and 1.");
+  }
+  return value;
+}

package/src/grammar/pathSeries.js

@@ -42,7 +42,7 @@ export function readPathSeriesFields(rows, layer) {
 
 function seriesValueIndex(rows, fields, field, channel, encoding = {}) {
   const quantitative = channel === "strokeWidth" || channel === "opacity";
-  const values = channel === "stroke"
+  const values = channel === "stroke" || (channel === "color" && encoding.fieldType === "quantitative")
     ? readScaleField(rows, field, encoding.fieldType ?? "nominal", {
         temporalUnit: encoding.temporalUnit
       })
@@ -88,7 +88,7 @@ export function validatePathSeriesAppearance(rows, layer) {
     if (encoding?.field === undefined) continue;
     const allowed = ["color", "stroke"].includes(channel)
       ? channel === "color"
-        ? ["nominal", "ordinal"]
+        ? layer.mark.type === "area" ? ["nominal", "ordinal", "quantitative"] : ["nominal", "ordinal"]
         : ["nominal", "ordinal", "quantitative", "temporal"]
       : channel === "strokeDash" ? ["nominal"] : ["quantitative"];
     if (!allowed.includes(encoding.fieldType)) {

package/src/grammar/pointShapes.js

@@ -14,7 +14,9 @@ export const POINT_SHAPES = cloneAndFreeze([
   "cross",
   "star",
   "hexagon",
-  "wye"
+  "wye",
+  "wedge",
+  "arrow"
 ]);
 
 const SHAPE_SET = new Set(POINT_SHAPES);
@@ -98,7 +100,19 @@ function shapePolygon(shape) {
     cross: rotate(plus, Math.PI / 4),
     star: alternatingPolygon(5, 0.45),
     hexagon: regularPolygon(6),
-    wye: alternatingPolygon(3, 0.28)
+    wye: alternatingPolygon(3, 0.28),
+    wedge: [
+      { x: 0, y: -2 / Math.sqrt(3) },
+      { x: -1 / 4, y: 1 / Math.sqrt(3) },
+      { x: 1 / 4, y: 1 / Math.sqrt(3) }
+    ],
+    // The directional arrow is anchored at its bounding-box center, not its centroid.
+    arrow: [
+      { x: -1 / 7, y: 1 }, { x: 1 / 7, y: 1 },
+      { x: 1 / 7, y: -1 / 8 }, { x: 2 / 5, y: -1 / 8 },
+      { x: 0, y: -1 }, { x: -2 / 5, y: -1 / 8 },
+      { x: -1 / 7, y: -1 / 8 }
+    ]
   }[shape];
 }
 

package/src/grammar/regression/derive.js

@@ -3,7 +3,7 @@ import {
   readNominalField,
   readQuantitativeField
 } from "../scales/index.js";
-import { fitRegressionGroup, predictRegressionAt } from "./models.js";
+import { fitRegressionGroup, predictRegressionAt, linearRegressionStatistics } from "./models.js";
 import { requireFiniteResult } from "../numeric.js";
 import {
   validateGeneratedItemLimit,
@@ -81,6 +81,7 @@ export function deriveRegression(values, {
   }
   const groups = [...groupedRows.keys()];
   const models = [];
+  const statistics = [];
   const rows = [];
   let work = 0;
 
@@ -119,6 +120,10 @@ export function deriveRegression(values, {
       parameters
     });
     models.push({ ...(groupBy === undefined ? {} : { group }), ...model, xValues });
+    if (parameters.method === "linear") statistics.push({
+      ...(groupBy === undefined ? {} : { group }),
+      ...linearRegressionStatistics(groupRows, model, { x, y })
+    });
 
     for (const xValue of xValues) {
       const prediction = predictRegressionAt(model, xValue, parameters);
@@ -163,6 +168,9 @@ export function deriveRegression(values, {
     parameters,
     groups,
     models,
+    ...(parameters.method === "linear" ? {
+      fitStatistics: { version: 1, method: "linear", groups: statistics }
+    } : {}),
     values: rows,
     ...(missing === undefined ? {} : {
       report: {

package/src/grammar/regression/models.js

@@ -477,7 +477,62 @@ function predictLoessAt(model, xValue) {
   }, "LOESS regression prediction").prediction;
 }
 
+function fitExponentialGroup(rows, { x, y, group }) {
+  const label = `Regression group "${group === undefined ? "all" : String(group)}"`;
+  if (rows.length < 2) throw new Error(`${label} requires at least two rows.`);
+  if (rows.some(row => !(row[y] > 0))) {
+    throw new RangeError("Exponential regression y values must be strictly positive.");
+  }
+  const xValues = rows.map(row => row[x]);
+  if (new Set(xValues).size < 2) throw new Error(`${label} requires varying x values.`);
+  const responseScale = maximumMagnitude(rows.map(row => row[y]));
+  const xMagnitude = maximumMagnitude(xValues) || 1;
+  const weights = rows.map(row => row[y] / responseScale);
+  const weightSum = weights.reduce((sum, value) => sum + value, 0);
+  const logs = rows.map(row => Math.log(row[y]));
+  const meanX = restoreFiniteScale(rows.reduce((sum, row, index) =>
+    sum + weights[index] * (row[x] / xMagnitude), 0) / weightSum,
+  xMagnitude, `${label} weighted x mean`);
+  const meanLogY = logs.reduce((sum, value, index) => sum + weights[index] * value, 0) / weightSum;
+  const [centeredX, xScale] = normalizedCoordinates(xValues, meanX);
+  const variance = centeredX.reduce((sum, value, index) => sum + weights[index] * value ** 2, 0);
+  if (variance === 0) throw new Error(`${label} requires varying x values.`);
+  const covariance = centeredX.reduce((sum, value, index) =>
+    sum + weights[index] * value * (logs[index] - meanLogY), 0);
+  const rate = restoreFiniteRatio(covariance / variance, 1, xScale, `${label} exponential rate`);
+  const logAmplitude = requireFiniteResult(meanLogY - rate * meanX, `${label} exponential log amplitude`);
+  const amplitude = requireFiniteResult(Math.exp(logAmplitude), `${label} exponential amplitude`);
+  if (amplitude === 0) throw new RangeError("Exponential regression amplitude must be positive and representable.");
+  return { count: rows.length, amplitude, rate, logAmplitude };
+}
+
+export function linearRegressionStatistics(rows, model, { x, y }) {
+  const responseScale = maximumMagnitude(rows.map(row => row[y])) || 1;
+  const [coordinates, xScale] = normalizedCoordinates(rows.map(row => row[x]), model.meanX);
+  const normalizedSlope = model.normalizedResponseSlope ?? (
+    Number.isFinite(model.slope * xScale) && (model.slope * xScale !== 0 || model.slope === 0)
+      ? model.slope * xScale / responseScale
+      : restoreFiniteRatio(model.slope, xScale, responseScale, "Linear regression normalized slope")
+  );
+  let residualSquares = 0;
+  let totalSquares = 0;
+  rows.forEach((row, index) => {
+    const difference = row[y] - model.meanY;
+    const centered = Number.isFinite(difference)
+      ? difference / responseScale
+      : row[y] / responseScale - model.meanY / responseScale;
+    const residual = centered - normalizedSlope * coordinates[index];
+    totalSquares += centered ** 2;
+    residualSquares += residual ** 2;
+  });
+  return {
+    count: rows.length, intercept: model.intercept, slope: model.slope,
+    rSquared: totalSquares === 0 ? null : 1 - residualSquares / totalSquares
+  };
+}
+
 export function fitRegressionGroup(rows, { x, y, group, parameters }) {
+  if (parameters.method === "exp") return fitExponentialGroup(rows, { x, y, group });
   if (parameters.method === "linear") {
     return fitLinearGroup(rows, {
       x,
@@ -509,9 +564,14 @@ export function predictRegressionAt(model, xValue, parameters) {
     : undefined;
   const prediction = parameters.method === "linear"
     ? linearPrediction(model, xValue)
+    : parameters.method === "exp"
+      ? requireFiniteResult(Math.exp(model.logAmplitude + model.rate * xValue), "Exponential regression prediction")
     : parameters.method === "polynomial"
       ? polynomial.prediction
       : predictLoessAt(model, xValue);
+  if (parameters.method === "exp" && prediction === 0) {
+    throw new RangeError("Exponential regression prediction must be positive and representable.");
+  }
   if (parameters.method === "loess" || parameters.interval === false) return { prediction };
   const leverage = parameters.method === "linear"
     ? model.normalizedSxx !== undefined

package/src/grammar/regression/parameters.js

@@ -51,9 +51,17 @@ export function normalizeRegressionParameters({
   confidence,
   interval
 } = {}) {
-  if (!["linear", "polynomial", "loess"].includes(method)) {
+  if (!["linear", "polynomial", "loess", "exp"].includes(method)) {
     throw new Error(`Unsupported regression method "${method}".`);
   }
+  if (method === "exp") {
+    if (degree !== undefined || span !== undefined || robustIterations !== undefined ||
+        confidenceMethod !== undefined || level !== undefined || confidence !== undefined ||
+        (interval !== undefined && interval !== false)) {
+      throw new Error("Exponential regression only supports interval false and no confidence or method-specific options.");
+    }
+    return cloneAndFreeze({ method, interval: false });
+  }
   if (method === "loess") {
     if (degree !== undefined) {
       throw new Error("Regression degree requires the polynomial method.");