ggaction 0.0.18 → 0.0.19

package/src/materialization/guides/resources.js

@@ -1 +1 @@
-import{unionConcreteGraphicBounds as h}from"../../grammar/schemas/graphicBounds.js";function z(e,t,o,n){const r=[],s=(i,a,c,f)=>{if(c===void 0)return;const k=f.filter(L=>e.objects[L]!==void 0),b=h(e,k,n);b!==void 0&&r.push({id:i,kind:a,position:c,bounds:b})};s("chart title","title",o?.position,["chartTitle","chartSubtitle"]);for(const i of["x","y"])for(const a of I(i)){const c=a.slice(`${i}Axis`.length).toLowerCase();s(`${i}-axis ${c}`,"axis",t.axis?.[i]?.[c]?.position,[a])}const l=S(),d=t.legend??{},p=l.find(i=>i.family==="categorical"&&d[i.kind]!==void 0),g=p!==void 0&&d.size!==void 0&&d[p.kind].target===d.size.target&&(d.size.inheritPosition!==!1||d[p.kind].position===d.size.position),m=t.legendGroups??{};for(const[i,a]of Object.entries(m)){const c=l.filter(f=>d[f.kind]?.target===i).flatMap(f=>f.graphicIds);s(`${i} legend group`,"legend",a.placement.position??"free",c)}for(const i of l){const a=d[i.kind];if(m[a?.target]!==void 0||a===void 0||g&&i.kind==="size")continue;const c=g&&i===p?[...i.graphicIds,...l.find(f=>f.kind==="size").graphicIds]:i.graphicIds;s(`${i.kind}${g&&i===p?"+size":""} legend`,"legend",a.position,c)}return r}const y=Object.freeze(["Line","Ticks","Labels","Title"]),u=Object.freeze(["Symbols","SymbolLines","SymbolPoints","SymbolSwatches","Labels","Title","Background"]),O=Object.freeze({series:Object.freeze({semanticKind:"series",family:"categorical",rematerializeOp:void 0,graphicIds:Object.freeze(u.map(e=>`seriesLegend${e}`))}),color:Object.freeze({semanticKind:"color",family:"categorical",rematerializeOp:void 0,graphicIds:Object.freeze(u.map(e=>`colorLegend${e}`))}),stroke:Object.freeze({semanticKind:"stroke",family:"categorical",rematerializeOp:void 0,graphicIds:Object.freeze(u.map(e=>`strokeLegend${e}`))}),size:Object.freeze({semanticKind:"size",family:"size",rematerializeOp:"rematerializeSizeLegend",graphicIds:Object.freeze(["sizeLegendBackground","sizeLegendSymbols","sizeLegendLabels","sizeLegendTitle"])}),gradient:Object.freeze({semanticKind:"color",family:"continuous",rematerializeOp:"rematerializeGradientLegend",graphicIds:Object.freeze(["colorGradientBackground","colorGradientStrips","colorGradientTicks","colorGradientSymbols","colorGradientLabels","colorGradientTitle"])}),interval:Object.freeze({semanticKind:"color",family:"interval",rematerializeOp:"rematerializeIntervalLegend",graphicIds:Object.freeze(["colorLegendBackground","colorLegendSymbols","colorLegendLabels","colorLegendTitle"])}),strokeGradient:Object.freeze({semanticKind:"stroke",family:"continuous",rematerializeOp:"rematerializeStrokeGradientLegend",graphicIds:Object.freeze(["strokeGradientBackground","strokeGradientStrips","strokeGradientTicks","strokeGradientLabels","strokeGradientTitle"])}),strokeInterval:Object.freeze({semanticKind:"stroke",family:"interval",rematerializeOp:"rematerializeStrokeIntervalLegend",graphicIds:Object.freeze(["strokeIntervalBackground","strokeIntervalSymbols","strokeIntervalLabels","strokeIntervalTitle"])}),opacity:Object.freeze({semanticKind:"opacity",family:"continuous",rematerializeOp:"rematerializeOpacityLegend",graphicIds:Object.freeze(["opacityLegendBackground","opacityLegendSymbols","opacityLegendLabels","opacityLegendTitle"])}),strokeWidth:Object.freeze({semanticKind:"strokeWidth",family:"strokeWidth",rematerializeOp:"rematerializeStrokeWidthLegend",graphicIds:Object.freeze(["strokeWidthLegendBackground","strokeWidthLegendSymbols","strokeWidthLegendLabels","strokeWidthLegendTitle"])})});function I(e){const t=e==="radius"?"radial":e;return y.map(o=>`${t}Axis${o}`)}function j(e){return x(e).graphicIds}function x(e){const t=O[e];if(t===void 0)throw new Error(`Unknown legend graphic kind "${e}".`);return t}function S(){return Object.entries(O).map(([e,t])=>({kind:e,...t}))}function v(e){return[...new Set(e.flatMap(j))]}function C(e,t,o){if(t.inferredOffset!==!0||!["top","bottom"].includes(t.position)||t.layout==="legacy-bottom")return t.offset;const n=z(e.graphicSpec,e.guideConfigs,void 0,e.materializationConfigs.textMetrics).filter(s=>s.kind==="axis"&&s.position===t.position),r=t.position==="bottom"?Math.max(0,...n.map(s=>s.bounds.bottom-o.y-o.height)):Math.max(0,...n.map(s=>o.y-s.bounds.top));return t.offset+r}function G(e,t,o){if(t!=="size"||o.inheritPosition===!1)return o;const n=["series","color","stroke"].map(r=>e.guideConfigs.legend?.[r]).find(r=>r?.target===o.target);return n===void 0?o:{...o,position:n.position,offset:n.offset,inferredOffset:n.inferredOffset}}function $(e,t){return[e,t].some(n=>Object.entries(n.guideConfigs.legend??{}).some(([r,s])=>{const l=G(n,r,s);return l.inferredOffset===!0&&["top","bottom"].includes(l.position)&&l.layout!=="legacy-bottom"})||Object.values(n.guideConfigs.legendGroups??{}).some(r=>r.inferredOffset===!0&&["top","bottom"].includes(r.placement.position)))&&[e,t].some(n=>z(n.graphicSpec,n.guideConfigs,void 0,n.materializationConfigs.textMetrics).some(r=>r.kind==="axis"&&["top","bottom"].includes(r.position)))}export{v as allLegendGraphicIds,I as axisGraphicIds,G as effectiveLegendOffsetConfig,j as legendGraphicIds,S as legendResourcePolicies,x as legendResourcePolicy,$ as needsLegendAxisReflow,z as resolveGuideCollisionBlocks,C as resolveLegendAxisOffset};
+import{axisGraphicIds as h}from"../../selectors/axes.js";import{localLegendPosition as m}from"../legendGroups.js";import{resolveConcreteGraphicBounds as G,unionConcreteGraphicBounds as v}from"../../grammar/schemas/graphicBounds.js";function y(e,t,s,o){const n=[],r=(i,a,l,c)=>{if(l===void 0)return;const p=c.filter(b=>e.objects[b]!==void 0),g=v(e,p,o);g!==void 0&&n.push({id:i,kind:a,position:l,bounds:g})};r("chart title","title",s?.position,["chartTitle","chartSubtitle"]);for(const[i,a]of Object.entries(t.axis??{})){const l=["line","ticks","labels","title"].map(p=>a[p]?.position).find(Boolean),c=["x","y"].includes(i)?i:["top","bottom"].includes(l)?"x":["left","right"].includes(l)?"y":void 0;if(c!==void 0)for(const[p,g]of["line","ticks","labels","title"].entries()){const b=h(c,i)[p],I=n.length;if(r(`${i}-axis ${g}`,"axis",a[g]?.position,[b]),n.length===I)continue;const z=n.at(-1);if(z.axisId=i,z.namedAxis=i!==c,["labels","title"].includes(g)){const x=e.objects[b];z.textBounds=x.items?.map(S=>G(e,S.id,o))??[z.bounds]}}}const f=T(),d=t.legend??{},u=f.find(i=>i.family==="categorical"&&d[i.kind]!==void 0),k=u!==void 0&&d.size!==void 0&&d[u.kind].target===d.size.target&&m(d[u.kind])===void 0&&m(d.size)===void 0&&(d.size.inheritPosition!==!1||d[u.kind].position===d.size.position),L=t.legendGroups??{};for(const[i,a]of Object.entries(L)){const l=f.filter(c=>d[c.kind]?.target===i&&m(d[c.kind])===void 0).flatMap(c=>c.graphicIds);r(`${i} legend group`,"legend",a.placement.position??"free",l)}for(const i of f){const a=d[i.kind];if(L[a?.target]!==void 0&&m(a)===void 0||a===void 0||k&&i.kind==="size")continue;const l=k&&i===u?[...i.graphicIds,...f.find(c=>c.kind==="size").graphicIds]:i.graphicIds;r(`${i.kind}${k&&i===u?"+size":""} legend`,"legend",m(a)??a.position,l)}return n}const O=Object.freeze(["Symbols","SymbolLines","SymbolPoints","SymbolSwatches","Labels","Title","Background"]),j=Object.freeze({colorSize:Object.freeze({semanticKind:"colorSize",family:"sampled",rematerializeOp:void 0,graphicIds:Object.freeze(["colorSizeLegendBackground","colorSizeLegendSymbols","colorSizeLegendLabels","colorSizeLegendTitle"])}),series:Object.freeze({semanticKind:"series",family:"categorical",rematerializeOp:void 0,graphicIds:Object.freeze(O.map(e=>`seriesLegend${e}`))}),color:Object.freeze({semanticKind:"color",family:"categorical",rematerializeOp:void 0,graphicIds:Object.freeze(O.map(e=>`colorLegend${e}`))}),stroke:Object.freeze({semanticKind:"stroke",family:"categorical",rematerializeOp:void 0,graphicIds:Object.freeze(O.map(e=>`strokeLegend${e}`))}),size:Object.freeze({semanticKind:"size",family:"size",rematerializeOp:"rematerializeSizeLegend",graphicIds:Object.freeze(["sizeLegendBackground","sizeLegendSymbols","sizeLegendLabels","sizeLegendTitle"])}),gradient:Object.freeze({semanticKind:"color",family:"continuous",rematerializeOp:"rematerializeGradientLegend",graphicIds:Object.freeze(["colorGradientBackground","colorGradientStrips","colorGradientTicks","colorGradientSymbols","colorGradientLabels","colorGradientTitle"])}),interval:Object.freeze({semanticKind:"color",family:"interval",rematerializeOp:"rematerializeIntervalLegend",graphicIds:Object.freeze(["colorLegendBackground","colorLegendSymbols","colorLegendLabels","colorLegendTitle"])}),strokeGradient:Object.freeze({semanticKind:"stroke",family:"continuous",rematerializeOp:"rematerializeStrokeGradientLegend",graphicIds:Object.freeze(["strokeGradientBackground","strokeGradientStrips","strokeGradientTicks","strokeGradientLabels","strokeGradientTitle"])}),strokeInterval:Object.freeze({semanticKind:"stroke",family:"interval",rematerializeOp:"rematerializeStrokeIntervalLegend",graphicIds:Object.freeze(["strokeIntervalBackground","strokeIntervalSymbols","strokeIntervalLabels","strokeIntervalTitle"])}),opacity:Object.freeze({semanticKind:"opacity",family:"continuous",rematerializeOp:"rematerializeOpacityLegend",graphicIds:Object.freeze(["opacityLegendBackground","opacityLegendSymbols","opacityLegendLabels","opacityLegendTitle"])}),strokeWidth:Object.freeze({semanticKind:"strokeWidth",family:"strokeWidth",rematerializeOp:"rematerializeStrokeWidthLegend",graphicIds:Object.freeze(["strokeWidthLegendBackground","strokeWidthLegendSymbols","strokeWidthLegendLabels","strokeWidthLegendTitle"])})});function B(e){return C(e).graphicIds}function C(e){const t=j[e];if(t===void 0)throw new Error(`Unknown legend graphic kind "${e}".`);return t}function T(){return Object.entries(j).map(([e,t])=>({kind:e,...t}))}function W(e){return[...new Set(e.flatMap(B))]}function w(e,t,s){if(t.inferredOffset!==!0||!["top","bottom"].includes(t.position)||t.layout==="legacy-bottom")return t.offset;const o=y(e.graphicSpec,e.guideConfigs,void 0,e.materializationConfigs.textMetrics).filter(r=>r.kind==="axis"&&r.position===t.position),n=t.position==="bottom"?Math.max(0,...o.map(r=>r.bounds.bottom-s.y-s.height)):Math.max(0,...o.map(r=>s.y-r.bounds.top));return t.offset+n}function K(e,t,s){if(t!=="size"||s.inheritPosition===!1)return s;const o=["series","color","stroke"].map(n=>e.guideConfigs.legend?.[n]).find(n=>n?.target===s.target);return o===void 0?s:{...s,position:o.position,offset:o.offset,inferredOffset:o.inferredOffset}}function M(e,t){return[e,t].some(o=>Object.entries(o.guideConfigs.legend??{}).some(([n,r])=>{const f=K(o,n,r);return f.inferredOffset===!0&&["top","bottom"].includes(f.position)&&f.layout!=="legacy-bottom"})||Object.values(o.guideConfigs.legendGroups??{}).some(n=>n.inferredOffset===!0&&["top","bottom"].includes(n.placement.position)))&&[e,t].some(o=>y(o.graphicSpec,o.guideConfigs,void 0,o.materializationConfigs.textMetrics).some(n=>n.kind==="axis"&&["top","bottom"].includes(n.position)))}export{W as allLegendGraphicIds,h as axisGraphicIds,K as effectiveLegendOffsetConfig,B as legendGraphicIds,T as legendResourcePolicies,C as legendResourcePolicy,M as needsLegendAxisReflow,y as resolveGuideCollisionBlocks,w as resolveLegendAxisOffset};

package/src/materialization/legendBorder.js

@@ -0,0 +1,28 @@
+import { preserveGraphicPlacement } from './graphicHierarchy.js';
+import { editGraphicProperties } from '../core/graphicProperties.js';
+
+function borderCommands({x,y,width,height}) {
+  return [{op:'M',x,y},{op:'L',x:x+width,y},{op:'L',x:x+width,y:y+height},
+    {op:'L',x,y:y+height},{op:'Z'}];
+}
+
+export function materializeLegendBorder(program,id,bounds,border) {
+  const dashed=border.strokeDash?.length>0,type=dashed?'path':'rect';
+  let next=program;
+  if(program.graphicSpec.objects[id]?.type!==type) {
+    const placement=preserveGraphicPlacement(program,id);
+    next=next.editGraphics({target:id,remove:true}).createGraphics({id,type,...placement});
+  }
+  return editGraphicProperties(next,id,{
+    ...(dashed?{commands:borderCommands(bounds)}:bounds),
+    fill:border.background,stroke:border.color,strokeWidth:border.lineWidth,
+    ...(dashed?{strokeDash:border.strokeDash}:{})
+  });
+}
+
+export function editLegendBorderBounds(program,id,bounds) {
+  if(program.graphicSpec.objects[id]?.type==='path') {
+    return program.editGraphics({target:id,property:'commands',value:borderCommands(bounds)});
+  }
+  return editGraphicProperties(program,id,{x:bounds.x,y:bounds.y,width:bounds.width,height:bounds.height});
+}

package/src/materialization/legendClip.js

@@ -0,0 +1,76 @@
+import{cloneAndFreeze}from'../core/immutable.js';
+import{namespaceGraphicId}from'../selectors/graphicCapacity.js';
+
+const clipPrefix=namespaceGraphicId('legendSampleClip','');
+import{categoricalLegendSymbolId}from'../grammar/legendBlocks.js';
+import{validateLegendClip}from'../grammar/legendClip.js';
+import{hasRectRadius}from'../grammar/roundedRect.js';
+import{resolvePrimitiveGraphicBounds}from'../grammar/schemas/graphicBounds.js';
+import{translatedProperties}from'./graphicTranslation.js';
+
+function roles(kind,config){
+ if(['series','color','stroke'].includes(kind))return config.symbol.layers.map(layer=>({
+  id:categoricalLegendSymbolId(config,layer.type),point:layer.type==='point',
+  type:layer.type==='line'?'line':layer.type==='point'?config.channels.includes('shape')?'collection':'circle':hasRectRadius(layer)?'collection':'rect'
+ }));
+ const prefix=kind==='gradient'?'colorGradient':`${kind}Legend`;
+ return [{id:`${prefix}Symbols`,type:'circle',point:true}];
+}
+function wrapped(owner){return owner?.children?.some(id=>id.startsWith(clipPrefix));}
+export function hasLegendClipGraphics(program){
+ return Object.values(program.graphicSpec.objects).some(wrapped);
+}
+function copyGraphic(program,objects){return program._clone({graphicSpec:cloneAndFreeze({...program.graphicSpec,objects})});}
+export function resetLegendClipGraphics(program){
+ if(!hasLegendClipGraphics(program))return program;
+ const objects={...program.graphicSpec.objects};
+ function remove(id){const object=objects[id];for(const child of object?.children??[])remove(child);delete objects[id];}
+ for(const[kind,config]of Object.entries(program.guideConfigs.legend??{})){
+  const descriptors=roles(kind,config);
+  if(!descriptors.some(role=>wrapped(objects[role.id])))continue;
+  for(const role of descriptors){
+   const owner=objects[role.id];if(!owner)continue;
+   for(const child of owner.children??[])remove(child);
+   objects[role.id]={type:role.type,items:[]};
+  }
+ }
+ return copyGraphic(program,objects);
+}
+function union(bounds){return bounds.reduce((a,b)=>a===undefined?b:{left:Math.min(a.left,b.left),right:Math.max(a.right,b.right),top:Math.min(a.top,b.top),bottom:Math.max(a.bottom,b.bottom)},undefined);}
+function anchorY(type,p){
+ if(type==='circle')return p.y;
+ if(type==='rect')return p.y+p.height/2;
+ throw new Error('Path samples require their authored glyph anchor.');
+}
+export function applyLegendClipGraphics(program,{force=false,anchors={}}={}){
+ if(program.context.deferLegendClip===true&&!force)return program;
+ let next=program;
+ for(const[kind,config]of Object.entries(program.guideConfigs.legend??{})){
+  validateLegendClip(kind,config);if(config.clipHeight===undefined)continue;
+  if (["series","color","stroke"].includes(kind) && anchors[kind] === undefined && !force) continue;
+  const descriptors=roles(kind,config),owners=descriptors.map(role=>next.graphicSpec.objects[role.id]);
+  if(owners.some(wrapped)||owners.some(owner=>!owner?.items))continue;
+  const count=owners[0].items.length;if(count===0||owners.some(owner=>owner.items.length!==count))continue;
+  const objects={...next.graphicSpec.objects},primary=descriptors[0].id,children=[];
+  for(let index=0;index<count;index++){
+   const samples=owners.map((owner,j)=>({item:owner.items[index],type:owner.items[index].type??owner.type,role:descriptors[j]}));
+   const point=samples.find(sample=>sample.role.point),y=anchors[kind]?.[index]??anchorY(point.type,point.item.properties);
+   const b=union(samples.map(sample=>resolvePrimitiveGraphicBounds(sample.type,sample.item.properties)));
+   const x=b.left,top=y-config.clipHeight/2,id=namespaceGraphicId('legendSampleClip',namespaceGraphicId(`${primary}:${index}`,'window')),glyphs=[];
+   for(const sample of samples){
+    const glyph=namespaceGraphicId(sample.item.id,'glyph');glyphs.push(glyph);
+    objects[glyph]={type:sample.type,properties:translatedProperties(sample.type,sample.item.properties,-x,-top)};
+   }
+   objects[id]={type:'canvas',properties:{x,y:top,width:b.right-b.left,height:config.clipHeight},children:glyphs};children.push(id);
+  }
+  for(const descriptor of descriptors)objects[descriptor.id]={type:'collection',items:[],...(descriptor.id===primary?{children}:{})};
+  next=copyGraphic(next,objects);
+ }
+ return next;
+}
+
+export function restoreLegendClipContext(program, previous) {
+ const {deferLegendClip: _deferred, ...context} = program.context;
+ if (previous !== undefined) context.deferLegendClip = previous;
+ return program._clone({context});
+}

package/src/materialization/legendGroups.js

@@ -1 +1 @@
-import{PLOT_LEGEND_POSITIONS as u}from"../layout/legend.js";function p(r,t){return r.guideConfigs.legendGroups?.[t]}function c(r,t){const n=p(r,t.target);if(n===void 0)return t;const o=n.placement.position,e=u.includes(o),i=e?t.direction==="horizontal"?"top":"right":o??(u.includes(t.position)?t.direction==="horizontal"?"top":"right":t.position??"right");return{...t,position:i,offset:0,align:"left",groupIntrinsic:!0,...e?{groupCorner:!0}:{},...i==="right"?{align:"center"}:{}}}export{c as intrinsicLegendConfig,p as legendGroup};
+import{localLegendPosition as c,localLegendPlacement as s}from"../grammar/legendGroups.js";import"../core/vocabulary.js";import{PLOT_LEGEND_POSITIONS as l}from"../layout/legend.js";function u(n,t){return n.guideConfigs.legendGroups?.[t]}function f(n,t){const e=s(t),o=e===void 0?u(n,t.target)??(n.context.facetLegendIntrinsic===!0?{placement:{position:t.position}}:void 0):{placement:e};if(o===void 0)return t;const i=o.placement.position,r=l.includes(i),p=r?t.direction==="horizontal"?"top":"right":i??(l.includes(t.position)?t.direction==="horizontal"?"top":"right":t.position??"right");return{...t,...e===void 0?{}:{blockLocalPosition:e.position},position:p,offset:0,align:"left",groupIntrinsic:!0,...r?{groupCorner:!0}:{},...p==="right"?{align:"center"}:{}}}export{f as intrinsicLegendConfig,u as legendGroup,s as localLegendPlacement,c as localLegendPosition};

package/src/materialization/legends.js

@@ -24,6 +24,6 @@ export function materializedLegendUsesScale(program, id) {
     const order = program.semanticSpec.guides.legend?.[kind]?.order;
     const linkedScale = order?.channel === undefined ? undefined
       : findLayer(program, config.target)?.encoding?.[order.channel]?.scale;
-    return config.scale === id || config.scales?.includes(id) || linkedScale === id;
+    return config.colorScale === id || config.sizeScale === id || config.scale === id || config.scales?.includes(id) || linkedScale === id;
   });
 }

package/src/materialization/scaleGuideDependencies.js

@@ -1,12 +1,10 @@
+import { cartesianAxisOwners, axisTargetArgs } from "../selectors/axes.js";
+import { axisGraphicIds } from "./guides/resources.js";
 import { isSourceOwnedText } from "../grammar/text.js";
 import { POSITION_ENCODING_CHANNELS } from "../core/vocabulary.js";
 import { materializedLegendUsesScale } from "./legends.js";
 import { buildMaterializationPlan } from "./planner.js";
 
-const CARTESIAN_AXES = Object.freeze([
-  Object.freeze({ channel: "x", prefix: "X", lineObject: "xAxisLine" }),
-  Object.freeze({ channel: "y", prefix: "Y", lineObject: "yAxisLine" })
-]);
 const POLAR_AXES = Object.freeze([
   Object.freeze({ channel: "theta", prefix: "Theta" }),
   Object.freeze({ channel: "radius", prefix: "Radial" })
@@ -18,8 +16,8 @@ const GRIDS = Object.freeze([
   Object.freeze({ role: "radial", op: "rematerializeRadialGrid" })
 ]);
 
-export function planAxisTickGridRematerialization(program, channel) {
-  const ticks = program.guideConfigs.axis?.[channel]?.ticks;
+export function planAxisTickGridRematerialization(program, channel, axisId = channel) {
+  const ticks = program.guideConfigs.axis?.[axisId]?.ticks;
   const role = channel === "x" ? "vertical" : "horizontal";
   const config = program.guideConfigs.grid?.[role];
   return buildMaterializationPlan({ guides:
@@ -48,9 +46,7 @@ function usesRadialScale(program, id) {
 
 function semanticGuideUsesScale(program, id) {
   return [
-    ...CARTESIAN_AXES.map(({ channel }) =>
-      program.semanticSpec.guides.axis?.[channel]
-    ),
+    ...cartesianAxisOwners(program).map(owner => owner.semantic),
     ...POLAR_AXES.map(({ channel }) =>
       program.semanticSpec.guides.axis?.[channel]
     ),
@@ -83,16 +79,19 @@ export function planScaleGuideRematerialization(program, id) {
       args: { target: guideConfigs.axis.parallel.axes.target }
     });
   }
-  for (const axis of CARTESIAN_AXES) {
+  for (const owner of cartesianAxisOwners(program)) {
+    const axis = { channel: owner.channel, prefix: owner.channel.toUpperCase(),
+      lineObject: axisGraphicIds(owner.channel, owner.id)[0] };
+    const target = owner.named ? { args: axisTargetArgs(owner.id, owner.channel) } : {};
     if (
       objects[axis.lineObject] &&
-      program.semanticSpec.guides.axis?.[axis.channel]?.scale === id
+      owner.scale === id
     ) {
-      guides.push({ op: componentEditOperation(axis.prefix, "line") });
+      guides.push({ op: componentEditOperation(axis.prefix, "line"), ...target });
     }
     for (const component of ["ticks", "labels", "title"]) {
-      if (guideConfigs.axis?.[axis.channel]?.[component]?.scale === id) {
-        guides.push({ op: componentEditOperation(axis.prefix, component) });
+      if (guideConfigs.axis?.[owner.id]?.[component]?.scale === id) {
+        guides.push({ op: componentEditOperation(axis.prefix, component), ...target });
       }
     }
   }

package/src/materialization/scales/map.js

@@ -22,8 +22,11 @@ export function mapScaleConsumerValues(values, resolvedScale, channel) {
       {
         type: resolvedScale.type,
         base: resolvedScale.base,
+        exponent: resolvedScale.exponent,
         constant: resolvedScale.constant,
         interpolation: resolvedScale.interpolate,
+        whitePoint: resolvedScale.whitePoint,
+        gamma: resolvedScale.gamma,
         midpoint: resolvedScale.midpoint,
         clamp: resolvedScale.clamp ?? false,
         ...(Object.hasOwn(resolvedScale, "unknown")

package/src/materialization/scales/resolve.js

@@ -200,6 +200,8 @@ function resolveContinuousScale({
             }
           : {}),
     ...(isSequentialColor ? { interpolate: scale.interpolate ?? "rgb" } : {}),
+    ...(scale.whitePoint === undefined ? {} : {whitePoint: scale.whitePoint}),
+    ...(scale.gamma === undefined ? {} : {gamma: scale.gamma}),
     ...(Object.hasOwn(scale, "unknown") ? { unknown: scale.unknown } : {})
   };
 }

package/src/materialization/typography.js

@@ -1,3 +1,5 @@
+import { cartesianAxisOwners, axisTargetArgs } from "../selectors/axes.js";
+import { axisGraphicIds } from "./guides/resources.js";
 import { applyMaterializationPlan, buildMaterializationPlan } from "./planner.js";
 import { withGuideLayoutTransaction } from "./guides/layout.js";
 
@@ -13,11 +15,17 @@ export function rematerializeTypography(program) {
     .map(layer => ({ op: "rematerializeTextMark", args: { id: layer.id } }));
   const guides = [];
   for (const [id, op] of [
-    ["xAxisLabels", "editXAxisLabels"], ["yAxisLabels", "editYAxisLabels"],
-    ["xAxisTitle", "editXAxisTitle"], ["yAxisTitle", "editYAxisTitle"],
     ["thetaAxisLabels", "editThetaAxisLabels"], ["radialAxisLabels", "editRadialAxisLabels"],
     ["thetaAxisTitle", "editThetaAxisTitle"], ["radialAxisTitle", "editRadialAxisTitle"]
   ]) if (exists(id, op)) guides.push({ op });
+  for (const owner of cartesianAxisOwners(program)) {
+    for (const [index, component] of [[2, "Labels"], [3, "Title"]]) {
+      const op = `edit${owner.channel.toUpperCase()}Axis${component}`;
+      if (exists(axisGraphicIds(owner.channel, owner.id)[index], op)) {
+        guides.push({ op, ...(owner.named ? { args: axisTargetArgs(owner.id, owner.channel) } : {}) });
+      }
+    }
+  }
   const parallel = program.guideConfigs.axis?.parallel?.axes;
   if (parallel !== undefined && typeof program.rematerializeParallelAxes === "function") {
     guides.push({ op: "rematerializeParallelAxes", args: { target: parallel.target } });

package/src/persistence/validation.js

@@ -1,9 +1,34 @@
+import { validateAuthoredFacetLegend } from "../grammar/facets/legendIntent.js";
+import { AXIS_RESOURCE_CHANNELS } from "../core/vocabulary.js";
+import { cartesianAxisOwners, assertCartesianAxisSideAvailable } from "../selectors/axes.js";
+import { axisGraphicIds } from "../selectors/axes.js";
+
+
+
+import {findLayer} from '../selectors/layers.js';
+import {findCoordinate} from '../selectors/coordinates.js';
+import {resolveColorSizeMapping,normalizeColorSizeSymbol} from '../grammar/colorSizeLegend.js';
+import{validateLegendClip}from"../grammar/legendClip.js";
+import {validateLegendLayerOpacity}from"../grammar/legendOpacity.js";
+import { isSizeShapeChannels, resolveSizeShapeMapping } from "../grammar/legendCombinations.js";
+import { describeLegendBlock } from "../grammar/legendBlocks.js";
+import { localLegendPosition } from "../grammar/legendGroups.js";
+import { normalizeLegendBorderDash } from "../grammar/legendBorder.js";
+import { normalizeNumericDisplayLabelMap } from "../grammar/displayLabels.js";
+import { isContinuousSizeScaleType } from "../grammar/scales/size.js";
+import { validateGraphicItemLimit } from "../core/validation.js";
 import { LEGEND_TITLE_STYLE_KEYS, validateLegendTitleAlignment } from "../grammar/legendTitleStyle.js";
+import { validateGuideDash, normalizeGuideDashMap } from "../grammar/guideDash.js";
+import { validateAxisTextPlacement } from "../grammar/axisTextPlacement.js";
 import { validateAreaPaintConfig } from "../grammar/areaPaint.js";
 import { validateOptionObject, validateKeys, validatePositiveFinite, validateNonNegativeFinite, validateNonEmptyString, validateGeneratedItemLimit } from "../core/validation.js";
+import { validateRegressionFitStatistics, requireRegressionStatisticsSource, regressionStatisticsRows } from "../grammar/regression/statistics.js";
+import { resolveGraphicItemCapacity } from "../selectors/graphicCapacity.js";
 import { isContinuousColorScaleType } from "../grammar/scales/types.js";
+import { normalizeColorInterpolationOptions } from "../grammar/scales/color.js";
+import { normalizeTransformParameters } from "../grammar/scales/transformed.js";
 import { validateLegendGroupState } from "../grammar/legendGroups.js";
-import { validateLegendGradient } from "../grammar/legendGradient.js";
+import { normalizeGradientDirection, validateLegendGradient } from "../grammar/legendGradient.js";
 import { normalizeTextMetricProfile } from "../core/textMetricProfile.js";
 import { isPlainObject } from "../core/immutable.js";
 import { validateUserId } from "../core/identifiers.js";
@@ -136,6 +161,12 @@ export function validateProgramState(program, path) {
     }
     resources.set(referenceKind, entries);
     for (const resource of entries.values()) {
+      if (kind === "scale") {
+        normalizeColorInterpolationOptions(resource.interpolate, resource);
+        if (resource.type === "pow") normalizeTransformParameters("pow", {
+          ...(resource.exponent === undefined ? {} : {exponent:resource.exponent})
+        });
+      }
       for (const [key, value] of Object.entries(resource)) {
         if (key !== "id") validateSemanticProperties(program, value, `${kind}[${resource.id}].${key}`);
       }
@@ -147,9 +178,121 @@ export function validateProgramState(program, path) {
   }
   for (const key of ["resolvedScales", "materializationConfigs", "context"]) requireObject(program[key], `${path}.${key}`);
   for (const key of ["marks", "guides"]) requireObject(program.materializationConfigs[key], `${path}.materializationConfigs.${key}`);
+  if (program.compositionSpec?.type === "facet" && isPlainObject(program.compositionSpec.facet.guides.legend)) {
+    validateAuthoredFacetLegend(program, program.compositionSpec.facet.guides.legend);
+  }
   if (program.materializationConfigs.textMetrics !== undefined) normalizeTextMetricProfile(program.materializationConfigs.textMetrics);
+  for (const config of [
+    ...Object.values(program.guideConfigs.axis ?? {}).map(axis => axis.ticks),
+    ...["horizontal", "vertical"].map(direction => program.guideConfigs.grid?.[direction])
+  ]) {
+    if (config?.strokeDash !== undefined) validateGuideDash(config.strokeDash);
+    if (config?.strokeDashMap !== undefined) normalizeGuideDashMap(config.strokeDashMap, { reset: false });
+  }
+  for (const owner of cartesianAxisOwners(program)) {
+    const channel = owner.id;
+    const axis = owner.config;
+    if (axis?.frame !== undefined) {
+      exactKeys(axis.frame, ["offset"], `${path}.guides.axis.${channel}.frame`);
+      validateNonNegativeFinite(axis.frame.offset, "Axis frame offset");
+    }
+    if (axis?.labels !== undefined) validateAxisTextPlacement(axis.labels);
+    if (axis?.title !== undefined) validateAxisTextPlacement(axis.title, { title: true });
+  }
+  for (const id of Object.keys(program.guideConfigs.axis ?? {})) {
+    if (!AXIS_RESOURCE_CHANNELS.includes(id) && !Object.hasOwn(program.semanticSpec.guides.axis ?? {}, id)) {
+      throw invalidSnapshot("Named axis configs require their semantic owner.", path);
+    }
+  }
+  for (const [id, semanticAxis] of Object.entries(program.semanticSpec.guides.axis ?? {})) {
+    if (AXIS_RESOURCE_CHANNELS.includes(id)) continue;
+    validateUserId(id, "Axis id");
+    validateKeys(semanticAxis, ["channel", "position", "scale", "coordinate", "title"], "Stored named axis");
+    if (!["x", "y"].includes(semanticAxis.channel) ||
+        !(semanticAxis.channel === "x" ? ["bottom", "top"] : ["left", "right"]).includes(semanticAxis.position)) {
+      throw invalidSnapshot("Named axes require a Cartesian channel and compatible physical side.", path);
+    }
+    validateUserId(semanticAxis.scale, "Axis scale id");
+    validateUserId(semanticAxis.coordinate, "Axis coordinate id");
+    if (resources.get("coordinate").get(semanticAxis.coordinate)?.type !== "cartesian") {
+      throw invalidSnapshot("Named Cartesian axes require a Cartesian coordinate.", path);
+    }
+    const config = program.guideConfigs.axis?.[id];
+    requireObject(config, `${path}.guides.axis.${id}`);
+    validateKeys(config, ["binding", "frame", "line", "ticks", "labels", "title"], "Stored named axis config");
+    const components = ["line", "ticks", "labels", "title"];
+    if (!components.some(component => config[component] !== undefined)) {
+      throw invalidSnapshot("Named axes require at least one retained component.", path);
+    }
+    for (const [index, component] of components.entries()) {
+      const stored = config[component];
+      const graphic = program.graphicSpec.objects[axisGraphicIds(semanticAxis.channel, id)[index]];
+      if ((program.compositionSpec === undefined && (stored !== undefined) !== (graphic !== undefined)) ||
+          (stored !== undefined && (stored.position !== semanticAxis.position ||
+            stored.scale !== undefined && stored.scale !== semanticAxis.scale))) {
+        throw invalidSnapshot("Named axis components must share their owner's side and scale.", path);
+      }
+    }
+    if ((semanticAxis.title !== undefined) !== (config.title !== undefined)) {
+      throw invalidSnapshot("Named axis title meaning requires its retained title component.", path);
+    }
+    assertCartesianAxisSideAvailable(program, { id, channel: semanticAxis.channel,
+      coordinate: semanticAxis.coordinate, position: semanticAxis.position });
+  }
   if (program.guideConfigs.legendGroups !== undefined) validateLegendGroupState(program.guideConfigs.legendGroups);
   for (const [kind, config] of Object.entries(program.guideConfigs.legend ?? {})) {
+    validateLegendClip(kind,config);
+    if (localLegendPosition(config) !== undefined) {
+      const descriptor = describeLegendBlock(program, kind, config);
+      for (const [key, override] of Object.entries(config.blockOverrides)) {
+        if (override.position !== undefined && key !== descriptor.key) throw invalidSnapshot("Local position requires its existing block owner.", path);
+      }
+    }
+    for(const layer of config.symbol?.layers??[])validateLegendLayerOpacity(layer.opacity);
+    if(kind==='colorSize') {
+      if(config.combine!=='color-size')throw invalidSnapshot('Color-size legend requires its combined owner.',path);
+      const layer=findLayer(program,config.target);
+      const mapping=resolveColorSizeMapping({layer,scales:program.resolvedScales,pointConfig:program.markConfigs[layer?.id],coordinate:findCoordinate(program,layer?.coordinate)});
+      for(const key of ['target','field','fieldType','colorScale','sizeScale','domain'])if(JSON.stringify(config[key])!==JSON.stringify(mapping[key]))throw invalidSnapshot('Stale color-size mapping.',path);
+      const guide=semantic.guides.legend?.colorSize;
+      if(guide?.colorScale!==mapping.colorScale||guide?.sizeScale!==mapping.sizeScale||guide.title!==config.title)throw invalidSnapshot('Stale color-size semantic owner.',path);
+      requireObject(config.symbol,path);normalizeColorSizeSymbol(config.symbol);
+      if(config.symbol.type!=='point'||!Object.hasOwn(config.symbol,'strokeWidth')||!Object.hasOwn(config.symbol,'opacity'))throw invalidSnapshot('Color-size symbol requires point type.',path);
+      const sample=config.sampling;requireObject(sample,path);
+      exactKeys(sample,sample.mode==='values'?['mode','count','values']:['mode','count'],path);
+      if(!['auto','values'].includes(sample.mode)||!Number.isInteger(sample.count)||sample.count<2)throw invalidSnapshot('Invalid color-size samples.',path);
+      validateGeneratedItemLimit(sample.count,'Color-size samples');
+      if(sample.mode==='values'){
+        requireArray(sample.values,path);
+        if(!sample.values.length||sample.values.length>100||sample.values.some((v,i)=>!Number.isFinite(v)||i>0&&v<=sample.values[i-1]||v<Math.min(...mapping.domain)||v>Math.max(...mapping.domain)||[mapping.colorScale,mapping.sizeScale].some(id=>program.resolvedScales[id].type==='log'&&v<=0)))throw invalidSnapshot('Invalid exact color-size samples.',path);
+      }
+    } else if (config.combine !== undefined) {
+      if (config.combine !== "size-shape" || kind !== "series" || !isSizeShapeChannels(config.channels)) throw invalidSnapshot("Invalid combined legend owner.", path);
+      const layer = semantic.layers.find(layer=>layer.id===config.target);
+      const definition = resolveSizeShapeMapping({layer,scales:program.resolvedScales,
+        order:semantic.guides.legend?.series?.order,rows:resolveDatasetReference(program,layer.data).values});
+      if (!Array.isArray(config.sizeAreas) || config.sizeAreas.length !== definition.sizeAreas.length ||
+          config.sizeAreas.some((area,index)=>!Object.is(area,definition.sizeAreas[index]))) throw invalidSnapshot("Stale combined legend size mapping.", path);
+    }
+    if (config.gradientDirection !== undefined) {
+      if (!["gradient", "strokeGradient"].includes(kind)) throw invalidSnapshot("Gradient direction requires a gradient owner.", path);
+      normalizeGradientDirection(config.gradientDirection, "Stored gradient direction");
+    }
+    if (["gradient", "strokeGradient"].includes(kind) && config.representation !== "symbols" && !["top", "bottom"].includes(config.titlePosition)) {
+      throw invalidSnapshot("Gradient titlePosition requires top or bottom.", path);
+    }
+    if (config.border && Object.hasOwn(config.border, "strokeDash")) {
+      normalizeLegendBorderDash(config.border.strokeDash, "Stored legend border strokeDash");
+    }
+    if (["size","colorSize"].includes(kind) && config.blockOverrides !== undefined) {
+      for (const [key, override] of Object.entries(config.blockOverrides)) {
+        if (override.labelMap === undefined) continue;
+        if (key !== (kind==='colorSize'?'["color","size"]':'["size"]') || !isContinuousSizeScaleType(program.resolvedScales[kind==='colorSize'?config.sizeScale:config.scale]?.type)) {
+          throw invalidSnapshot("Numeric display labels require a continuous size legend block.", path);
+        }
+        normalizeNumericDisplayLabelMap(override.labelMap, "Stored size legend labelMap");
+      }
+    }
     if (config.titleStyle !== undefined) {
       validateOptionObject(config.titleStyle, LEGEND_TITLE_STYLE_KEYS, "Stored legend title style");
       validateLegendTitleAlignment(config.titleStyle, config.titlePosition);
@@ -186,6 +329,27 @@ export function validateProgramState(program, path) {
     } else if (["sampling", "symbol", "columns", "direction", "layout"].some(key => config[key] !== undefined)) throw invalidSnapshot("Gradient color legend cannot store symbol representation settings.", path);
   }
 
+  const regressionFits = program.materializationConfigs.regressionFits ?? {};
+  requireObject(regressionFits, `${path}.materializationConfigs.regressionFits`);
+  for (const [id, cache] of Object.entries(regressionFits)) {
+    const dataset = resources.get("data").get(id);
+    validateRegressionFitStatistics(cache, dataset, resources.get("data").get(dataset?.source));
+  }
+  for (const dataset of semantic.datasets) {
+    if (dataset.transform?.[0]?.type !== "regressionStatistics") continue;
+    const fit = resources.get("data").get(dataset.source);
+    requireRegressionStatisticsSource(fit);
+    if (regressionFits[fit.id] === undefined) throw invalidSnapshot("Regression statistics requires its linear fit cache.", path);
+    if (dataset.values !== undefined) {
+      const expected = regressionStatisticsRows(regressionFits[fit.id], fit);
+      if (dataset.values.length !== expected.length || dataset.values.some((row, index) =>
+        !isPlainObject(row) || Object.keys(row).length !== Object.keys(expected[index]).length ||
+        Object.entries(expected[index]).some(([key, value]) => !Object.hasOwn(row, key) || !Object.is(row[key], value)))) {
+        throw invalidSnapshot("Regression statistics values do not match their linear fit cache.", path);
+      }
+    }
+  }
+
   const selections = program.materializationConfigs.selections ?? {};
   requireObject(selections, `${path}.materializationConfigs.selections`);
   for (const [id, selection] of Object.entries(selections)) {
@@ -205,6 +369,10 @@ export function validateProgramState(program, path) {
     requireObject(scale, `${path}.resolvedScales.${id}`);
     requireArray(scale.domain, `${path}.resolvedScales.${id}.domain`);
     requireArray(scale.range, `${path}.resolvedScales.${id}.range`);
+    normalizeColorInterpolationOptions(scale.interpolate, scale);
+    if (scale.type === "pow") normalizeTransformParameters("pow", {
+      ...(scale.exponent === undefined ? {} : {exponent:scale.exponent})
+    });
     if (!resources.get("scale").has(id) || scale.type !== resources.get("scale").get(id).type) {
       throw invalidSnapshot(`Resolved scale "${id}" has no matching semantic owner/type.`, path);
     }
@@ -229,4 +397,9 @@ export function validateProgramState(program, path) {
     for (const resource of resources.get(kind).values()) visit(resource);
   }
   validateGraphic(program.graphicSpec, `${path}.graphicSpec`);
+  for (const [id, graphic] of Object.entries(program.graphicSpec.objects)) {
+    if (graphic.items !== undefined) validateGraphicItemLimit(graphic.items.length, resolveGraphicItemCapacity(program, {
+      id, label: "Graphic collection length"
+    }));
+  }
 }

package/src/persistence.js

@@ -96,7 +96,7 @@ function migrateStateSchemas(state) {
         sourceSchema,
         dataset.transform?.[0] ?? {},
         dataset.values,
-        { sourceId: dataset.source, ownerId: dataset.id }
+        { sourceId: dataset.source, ownerId: dataset.id, sourceTransform: byId.get(dataset.source)?.transform?.[0] }
       );
     }
     active.delete(id);

package/src/renderers/canvas/index.js

@@ -1,3 +1,5 @@
+import { MAX_RASTER_DIMENSION, MAX_RASTER_PIXELS } from "./limits.js";
+import { prepareIsolatedGlyphs, drawIsolatedGlyph } from "./isolated.js";
 import { resolveCanvasSolidPaint } from "./fill.js";
 import { annotateError } from "../../core/diagnostics.js";
 import { drawCircleGraphic } from "./circle.js";
@@ -40,8 +42,6 @@ const DRAWING_CONTEXT_METHODS = Object.freeze([
   "rotate",
   "fillText"
 ]);
-const MAX_RASTER_DIMENSION = 32_767;
-const MAX_RASTER_PIXELS = 16_777_216;
 
 function requireDrawingContext(context) {
   if (context === null || typeof context !== "object") {
@@ -144,9 +144,10 @@ export function resolveGraphicRenderTarget(graphicSpec) {
   });
 }
 
-export function drawResolvedGraphicSpec(target, context) {
+export function drawResolvedGraphicSpec(target, context, options = {}) {
   requireDrawingContext(context);
   const { graphicSpec, canvasId, canvas, width, height } = target;
+  const isolated = options.isolated ?? prepareIsolatedGlyphs(target, context, options);
 
   fillCanvasBackground(context, canvasId, canvas, width, height);
 
@@ -162,14 +163,14 @@ export function drawResolvedGraphicSpec(target, context) {
         return;
       }
       if (!Array.isArray(object.items)) {
-        drawConcreteGraphic(context, id, object);
+        drawConcreteGraphic(context, id, object, isolated);
       }
     },
     item({ id, object, owner }) {
       drawConcreteGraphic(context, id, {
         ...object,
         type: object.type ?? owner.type
-      });
+      }, isolated);
     },
     exit({ id, object }) {
       if (
@@ -182,7 +183,7 @@ export function drawResolvedGraphicSpec(target, context) {
   });
 }
 
-export function render(program, context, { pixelRatio = 1 } = {}) {
+export function renderCanvasProgram(program, context, { pixelRatio = 1 } = {}, createCanvas) {
   const graphicSpec = requireProgramGraphicSpec(program);
 
   requireCanvasContext(context);
@@ -220,6 +221,7 @@ export function render(program, context, { pixelRatio = 1 } = {}) {
     ), { code: "resource-limit", operation: "render", optionPath: "physicalPixels", limit: MAX_RASTER_PIXELS, actual: physicalWidth * physicalHeight });
   }
   preflightCanvasGraphicSpec(target, pixelRatio);
+  const isolated = prepareIsolatedGlyphs(target, context, {pixelRatio, createCanvas});
 
   context.canvas.width = physicalWidth;
   context.canvas.height = physicalHeight;
@@ -235,16 +237,20 @@ export function render(program, context, { pixelRatio = 1 } = {}) {
   try {
     context.scale(pixelRatio, pixelRatio);
     context.clearRect(0, 0, width, height);
-    drawResolvedGraphicSpec(target, context);
+    drawResolvedGraphicSpec(target, context, {isolated, pixelRatio, createCanvas});
   } finally {
     context.restore();
   }
 }
 
-function drawConcreteGraphic(context, id, graphic) {
+export function render(program, context, options) {
+  return renderCanvasProgram(program, context, options);
+}
+
+function drawConcreteGraphic(context, id, graphic, isolated) {
   if (graphic.type === "collection") {
     for (const item of graphic.items ?? []) {
-      drawConcreteGraphic(context, item.id ?? id, item);
+      drawConcreteGraphic(context, item.id ?? id, item, isolated);
     }
     return;
   }
@@ -252,5 +258,9 @@ function drawConcreteGraphic(context, id, graphic) {
   if (draw === undefined) {
     throw new Error(`Canvas renderer does not support "${graphic.type}" yet.`);
   }
-  draw(context, id, graphic);
+  if (["normal","difference"].includes(graphic.properties?.blend)) {
+    drawIsolatedGlyph(context, id, graphic, draw, isolated);
+  } else {
+    draw(context, id, graphic);
+  }
 }