ggaction 0.0.17 → 0.0.19

package/src/materialization/guides/layout.js

@@ -1,57 +1 @@
-import { assertGuideCollisionBlocks } from "../../layout/guideCollisions.js";
-import { unionConcreteGraphicBounds } from "../../grammar/schemas/graphicBounds.js";
-import { axisGraphicIds, legendResourcePolicies } from "./resources.js";
-
-// Only domain-owned guides participate. Extension primitives may deliberately
-// overlap, and a combined categorical/size legend is one occupied group.
-export function resolveGuideCollisionBlocks(graphicSpec, guideConfigs, titleConfig, profile) {
-  const blocks = [];
-  const append = (id, kind, position, ids) => {
-    if (position === undefined) return;
-    const existing = ids.filter(id => graphicSpec.objects[id] !== undefined);
-    const bounds = unionConcreteGraphicBounds(graphicSpec, existing, profile);
-    if (bounds !== undefined) blocks.push({ id, kind, position, bounds });
-  };
-  append("chart title", "title", titleConfig?.position, ["chartTitle", "chartSubtitle"]);
-  for (const channel of ["x", "y"]) {
-    for (const id of axisGraphicIds(channel)) {
-      const component = id.slice(`${channel}Axis`.length).toLowerCase();
-      append(`${channel}-axis ${component}`, "axis", guideConfigs.axis?.[channel]?.[component]?.position, [id]);
-    }
-  }
-  const policies = legendResourcePolicies();
-  const configs = guideConfigs.legend ?? {};
-  const categorical = policies.find(policy => policy.family === "categorical" && configs[policy.kind] !== undefined);
-  const combined = categorical !== undefined && configs.size !== undefined &&
-    configs[categorical.kind].target === configs.size.target;
-  for (const policy of policies) {
-    const config = configs[policy.kind];
-    if (config === undefined || combined && policy.kind === "size") continue;
-    const ids = combined && policy === categorical
-      ? [...policy.graphicIds, ...policies.find(item => item.kind === "size").graphicIds]
-      : policy.graphicIds;
-    append(`${policy.kind}${combined && policy === categorical ? "+size" : ""} legend`, "legend", config.position, ids);
-  }
-  return blocks;
-}
-
-
-// Defer cross-guide checks while sibling materializers still carry old
-// coordinates. The scope is transient and never survives a returned program.
-export function withGuideLayoutTransaction(program, apply) {
-  if (program.context.deferGuideLayoutValidation === true) return apply(program);
-  const result = apply(program._withContext({ deferGuideLayoutValidation: true }));
-  const { deferGuideLayoutValidation: _deferred, ...context } = result.context;
-  if (Object.hasOwn(program.context, "deferGuideLayoutValidation")) {
-    context.deferGuideLayoutValidation = program.context.deferGuideLayoutValidation;
-  }
-  const next = result._clone({ context });
-  assertGuideCollisionBlocks(resolveGuideCollisionBlocks(next.graphicSpec, next.guideConfigs, next.titleConfig, next.materializationConfigs.textMetrics));
-  return next;
-}
-
-export function withGuideLayoutValidation(implementation) {
-  return function (args) {
-    return withGuideLayoutTransaction(this, program => implementation.call(program, args));
-  };
-}
+import{resetLegendClipGraphics as u,hasLegendClipGraphics as c}from"../legendClip.js";import{localLegendPosition as g}from"../legendGroups.js";import{needsLegendAxisReflow as m}from"./resources.js";import{getErrorDetails as p}from"../../core/diagnostics.js";import{planCanvasRematerialization as h}from"../layout.js";import{applyMaterializationPlan as C}from"../planner.js";import{assertGuideCollisionBlocks as L}from"../../layout/guideCollisions.js";import{resolveGuideCollisionBlocks as v}from"./resources.js";import{resolveGuideCollisionBlocks as M}from"./resources.js";function G(i,d){if(i.context.deferGuideLayoutValidation===!0)return d(i);const a=i.materializationConfigs.canvas?.plot;let n=i.materializationConfigs.canvas?.margin,e;for(let s=0;;s+=1)try{let t=u(i)._withContext({deferGuideLayoutValidation:!0});s>0&&(t=t.editGraphics({target:"canvas",property:"width",value:a.width+n.left+n.right}).editGraphics({target:"canvas",property:"height",value:a.height+n.top+n.bottom})._withCanvasConfig({...t.materializationConfigs.canvas,margin:n}),t=C(t,h(t))),e=d(t),c(i)&&!c(e)&&Object.values(e.guideConfigs.legend??{}).some(o=>o.clipHeight!==void 0)&&(e=e.rematerializeLegend()),e.compositionSpec===void 0&&Object.values(e.guideConfigs.legend??{}).some(o=>["left","right"].includes(o.position))&&(e=e.rematerializeSideLegendLane()),e.compositionSpec===void 0&&m(i,e)&&(e=e.rematerializeHorizontalLegendLane()),e.compositionSpec===void 0&&(Object.keys(e.guideConfigs.legendGroups??{}).length>0||Object.values(e.guideConfigs.legend??{}).some(o=>g(o)!==void 0))&&(e=e.rematerializeLegendGroups()),a!==void 0&&e.titleConfig!==void 0&&(e=e.rematerializeTitle());break}catch(t){const o=p(t)?.canvasOverflow;if(a===void 0||o===void 0||s>=16)throw t;n=Object.fromEntries(Object.keys(n).map(l=>[l,o[l]>0?Math.ceil((n[l]+o[l])*4)/4:n[l]]))}const{deferGuideLayoutValidation:y,...f}=e.context;Object.hasOwn(i.context,"deferGuideLayoutValidation")&&(f.deferGuideLayoutValidation=i.context.deferGuideLayoutValidation);const r=e._clone({context:f});return L(v(r.graphicSpec,r.guideConfigs,r.titleConfig,r.materializationConfigs.textMetrics)),r}function S(i){return function(d){return G(this,a=>i.call(a,d))}}export{M as resolveGuideCollisionBlocks,G as withGuideLayoutTransaction,S as withGuideLayoutValidation};

package/src/materialization/guides/resources.js

@@ -1,123 +1 @@
-const AXIS_COMPONENTS = Object.freeze(["Line", "Ticks", "Labels", "Title"]);
-
-const CATEGORICAL_COMPONENTS = Object.freeze([
-  "Symbols", "SymbolLines", "SymbolPoints", "SymbolSwatches",
-  "Labels", "Title", "Background"
-]);
-
-const LEGEND_RESOURCE_POLICIES = Object.freeze({
-  series: Object.freeze({
-    semanticKind: "series",
-    family: "categorical",
-    rematerializeOp: undefined,
-    graphicIds: Object.freeze(CATEGORICAL_COMPONENTS.map(
-      component => `seriesLegend${component}`
-    ))
-  }),
-  color: Object.freeze({
-    semanticKind: "color",
-    family: "categorical",
-    rematerializeOp: undefined,
-    graphicIds: Object.freeze(CATEGORICAL_COMPONENTS.map(
-      component => `colorLegend${component}`
-    ))
-  }),
-  stroke: Object.freeze({
-    semanticKind: "stroke",
-    family: "categorical",
-    rematerializeOp: undefined,
-    graphicIds: Object.freeze(CATEGORICAL_COMPONENTS.map(
-      component => `strokeLegend${component}`
-    ))
-  }),
-  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",
-      "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"
-    ])
-  })
-});
-
-export function axisGraphicIds(channel) {
-  const prefix = channel === "radius" ? "radial" : channel;
-  return AXIS_COMPONENTS.map(component => `${prefix}Axis${component}`);
-}
-
-export function legendGraphicIds(kind) {
-  return legendResourcePolicy(kind).graphicIds;
-}
-
-export function legendResourcePolicy(kind) {
-  const policy = LEGEND_RESOURCE_POLICIES[kind];
-  if (policy === undefined) {
-    throw new Error(`Unknown legend graphic kind "${kind}".`);
-  }
-  return policy;
-}
-
-export function legendResourcePolicies() {
-  return Object.entries(LEGEND_RESOURCE_POLICIES).map(([kind, policy]) => ({
-    kind,
-    ...policy
-  }));
-}
-
-export function allLegendGraphicIds(kinds) {
-  return [...new Set(kinds.flatMap(legendGraphicIds))];
-}
+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/layout.js

@@ -1,4 +1,57 @@
+import { canDeferScaleConsumerApplication, getLayerScaleIds, getMarkMaterializationStep } from "./marks/index.js";
+import { buildMaterializationPlan } from "./planner.js";
+import { hasMaterializedLegend } from "./legends.js";
+import { needsCanvasScaleRematerialization, planScaleGuideRematerialization } from "./scaleGuideDependencies.js";
+
+export function planCanvasRematerialization(program) {
+  const marks = [];
+  for (const layer of program.semanticSpec.layers) {
+    const step = getMarkMaterializationStep(program, layer);
+    if (step !== undefined) marks.push(step);
+  }
+  const deferredMarkIds = new Set(
+    marks
+      .map(step => step.args.id)
+  );
+  const scales = [];
+  for (const scale of program.semanticSpec.scales) {
+    if (needsCanvasScaleRematerialization(program, scale)) {
+      const deferredConsumers = program.semanticSpec.layers.filter(layer =>
+        canDeferScaleConsumerApplication(layer) &&
+        getLayerScaleIds(layer).includes(scale.id)
+      );
+      const canDeferMarks = deferredConsumers.length === 0 ||
+        deferredConsumers.every(layer => deferredMarkIds.has(layer.id));
+      scales.push({
+        op: "rematerializeScale",
+        args: {
+          id: scale.id,
+          guides: false,
+          ...(canDeferMarks ? { marks: false } : {})
+        }
+      });
+    }
+  }
+  const guides = program.semanticSpec.scales.flatMap(scale =>
+    needsCanvasScaleRematerialization(program, scale)
+      ? planScaleGuideRematerialization(program, scale.id)
+      : []
+  );
+  if (hasMaterializedLegend(program)) {
+    guides.push({ op: "rematerializeLegend" });
+  }
+  const layout = planLayoutRematerialization(program);
+  return buildMaterializationPlan({ scales, marks, guides, layout });
+}
+
+
 const LAYOUT_CONSUMER_POLICIES = Object.freeze([
+  Object.freeze({
+    applies(program) {
+      return program.compositionSpec === undefined && program.materializationConfigs?.canvas?.plotBorder !== undefined;
+    },
+    step: Object.freeze({ op: "rematerializePlotBorder" })
+  }),
   Object.freeze({
     applies(program) {
       return program.semanticSpec.title.text !== undefined &&

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

@@ -0,0 +1 @@
+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/legendText.js

@@ -0,0 +1 @@
+import{materializeTextLines as o}from"./textLines.js";import{resolveLegendTitleText as l}from"../layout/legendText.js";function m(e,i,t,n){const{lines:r}=l(t,n,e.materializationConfigs.textMetrics);return o(e,i,r)}export{m as materializeLegendTitleLines};

package/src/materialization/legends.js

@@ -2,7 +2,7 @@ import { findLayer } from "../selectors/layers.js";
 import { LEGEND_CONFIG_KINDS } from "../core/vocabulary.js";
 
 export function isOpacityLegendLayer(layer) {
-  return ["point", "line"].includes(layer.mark?.type) &&
+  return ["point", "line", "bar"].includes(layer.mark?.type) &&
     layer.encoding?.opacity?.scale !== undefined;
 }
 
@@ -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/marks/capabilities.js

@@ -60,10 +60,10 @@ export function canMaterializeLine(program, layer) {
     layer.mark?.type === "line" &&
     hasCartesianPositionScales(layer) &&
     ((isAggregate(layer.encoding.y.aggregate) &&
-      (layer.encoding.x.fieldType === "temporal" ||
+      (["temporal", "nominal", "ordinal"].includes(layer.encoding.x.fieldType) ||
         (layer.encoding.x.fieldType === "quantitative" &&
           layer.encoding.x.bin !== undefined))) ||
-      (layer.encoding.x.fieldType === "quantitative" &&
+      (["quantitative", "nominal", "ordinal"].includes(layer.encoding.x.fieldType) &&
         layer.encoding.y.fieldType === "quantitative") ||
       ((interval || layer.encoding.y.aggregate === undefined) &&
         ["quantitative", "temporal"].includes(layer.encoding.x.fieldType) &&
@@ -114,15 +114,14 @@ export function canMaterializeArc(_program, layer) {
   }
   if (layer.encoding.theta.fieldType === "quantitative") {
     return (
-      layer.encoding.theta.aggregate === undefined &&
-      layer.encoding?.radius === undefined
+      layer.encoding.theta.aggregate === undefined
     );
   }
   if (!["nominal", "ordinal"].includes(layer.encoding.theta.fieldType)) {
     return false;
   }
   if (["count", "sum"].includes(layer.encoding.theta.aggregate)) {
-    return layer.encoding?.radius === undefined;
+    return true;
   }
   return (
     layer.encoding.theta.aggregate === undefined &&
@@ -136,7 +135,7 @@ export function canMaterializeBar(program, layer) {
     return false;
   }
   const grain = resolveBarGrain(layer);
-  if (![BAR_GRAINS.histogram, BAR_GRAINS.aggregate, BAR_GRAINS.ranged].includes(grain)) {
+  if (![BAR_GRAINS.histogram, BAR_GRAINS.aggregate, BAR_GRAINS.ranged, BAR_GRAINS.centered].includes(grain)) {
     return false;
   }
   if (

package/src/materialization/rect.js

@@ -144,7 +144,7 @@ export function resolveRectRows(program, layer, dataset) {
 }
 
 export function resolveRectGraphicItems(program, layer, dataset) {
-  const radius = program.markConfigs[layer.id]?.cornerRadius ?? 0;
+  const radius = program.markConfigs[layer.id] ?? {};
   return resolveRectRows(program, layer, dataset).map(item =>
     materializeRectItem(item.properties, radius)
   );

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]
     ),
@@ -64,7 +60,7 @@ export function needsCanvasScaleRematerialization(program, scale) {
       usesRadialScale(program, scale.id) ||
       semanticGuideUsesScale(program, scale.id)) &&
     (program.resolvedScales[scale.id] !== undefined || scale.radialMapping !== undefined) &&
-    usesPositionalScale(program, scale.id)
+    (usesPositionalScale(program, scale.id) || semanticGuideUsesScale(program, scale.id))
   );
 }
 
@@ -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

@@ -20,7 +20,13 @@ export function mapScaleConsumerValues(values, resolvedScale, channel) {
       resolvedScale.domain,
       resolvedScale.range,
       {
+        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/policies/arc.js

@@ -1,3 +1,4 @@
+import { resolveArcInnerRadius } from "../../../grammar/arcs.js";
 import { validateMeasuredRadiusScale } from "../../../grammar/scales/radial.js";
 export function resolveArcAutoPositionRange({
   consumers,
@@ -15,16 +16,16 @@ export function resolveArcAutoPositionRange({
     return range;
   }
   if (channel === "radius") {
-    const ratios = consumers.map(
-      consumer => markConfigs[consumer.layer.id]?.innerRadius ?? 0
-    );
-    if (new Set(ratios).size !== 1) {
+    const outer = Math.max(...range);
+    const inner = consumers.map(consumer => resolveArcInnerRadius(
+      markConfigs[consumer.layer.id]?.innerRadius ?? 0, outer
+    ));
+    if (new Set(inner).size !== 1) {
       throw new Error(
         `Shared arc radius scale "${scale.id}" requires one innerRadius policy.`
       );
     }
-    const outer = Math.max(...range);
-    return [outer * ratios[0], outer];
+    return [inner[0], outer];
   }
   if (
     channel === "theta" &&
@@ -67,7 +68,7 @@ export function validateMeasuredRadiusConsumers({ scale, domain, range, consumer
     const config = markConfigs[layer.id] ?? {};
     if ((config.padAngle ?? 0) !== 0) throw new Error("Measured Arc requires padAngle 0.");
     if (scale.range !== "auto" && config.innerRadiusExplicit === true &&
-      Math.abs(config.innerRadius - range[0] / range[1]) > Number.EPSILON * 8) {
+      Math.abs(resolveArcInnerRadius(config.innerRadius, range[1]) / range[1] - range[0] / range[1]) > Number.EPSILON * 8) {
       throw new Error("Measured Arc innerRadius must agree with its explicit radius range.");
     }
   }

package/src/materialization/scales/policies/bar.js

@@ -7,14 +7,19 @@ import {
   interpolateNumber,
   inverseLerp
 } from "../../../grammar/numeric.js";
-export function resolveTemporalBarBand(valuesByConsumer, domain, range) {
+export function resolveTemporalBarBand(valuesByConsumer, domain, range, markConfigs = {}, preserveRange = false) {
   const temporalBars = valuesByConsumer.filter(({ consumer }) => {
     const channels = resolveBarChannels(consumer.layer);
-    return resolveBarGrain(consumer.layer) === BAR_GRAINS.aggregate &&
+    return [BAR_GRAINS.aggregate, BAR_GRAINS.ranged].includes(resolveBarGrain(consumer.layer)) &&
       channels?.category === consumer.channel &&
       consumer.encoding.fieldType === "temporal";
   });
   if (temporalBars.length === 0) return undefined;
+  const intervalBars = temporalBars.filter(({consumer}) => markConfigs[consumer.layer.id]?.barWidth?.interval !== undefined);
+  if (intervalBars.length > 0) {
+    if (intervalBars.length !== temporalBars.length) throw new Error("Temporal interval and centered bar widths cannot share a position scale.");
+    return undefined;
+  }
   const temporalFields = new Set(
     temporalBars.map(({ consumer }) => consumer.encoding.field)
   );
@@ -31,6 +36,11 @@ export function resolveTemporalBarBand(valuesByConsumer, domain, range) {
       "A temporal bar position scale requires compatible bar, line, rule, or text consumers of one field."
     );
   }
+  // Explicit pixel widths do not need an inferred half-slot inset. Keep one
+  // common range when a shared scale also has band-width bar consumers.
+  preserveRange ||= temporalBars.every(({ consumer }) =>
+    markConfigs[consumer.layer.id]?.barWidth?.pixels !== undefined
+  );
   const values = temporalBars.flatMap(item => item.values);
   const ordered = [...new Set(values)].sort((left, right) => left - right);
   if (ordered.length < 2) {
@@ -59,7 +69,7 @@ export function resolveTemporalBarBand(valuesByConsumer, domain, range) {
       interpolateNumber(range[0], range[1], bandwidthFraction) - range[0]
     )
     : directBandwidth;
-  const resolvedRange = stable
+  const resolvedRange = preserveRange ? [...range] : stable
     ? [
         interpolateNumber(range[0], range[1], bandwidthFraction / 2),
         interpolateNumber(range[0], range[1], 1 - bandwidthFraction / 2)
@@ -79,10 +89,12 @@ export function resolveTemporalBarBand(valuesByConsumer, domain, range) {
   });
   let bandwidth = Infinity;
   for (let index = 1; index < positions.length; index += 1) {
-    bandwidth = Math.min(
-      bandwidth,
-      Math.abs(positions[index] - positions[index - 1])
-    );
+    const gap = Math.abs(positions[index] - positions[index - 1]);
+    // Keep a finite conservative slot when an explicitly requested span itself
+    // exceeds the representable difference of two finite endpoints.
+    bandwidth = Math.min(bandwidth,
+      preserveRange && !Number.isFinite(gap) ? estimatedBandwidth : gap);
+
   }
   if (![estimatedBandwidth, bandwidth, ...resolvedRange].every(Number.isFinite)) {
     throw new RangeError("Temporal bar position exceeds the finite numeric range.");

package/src/materialization/scales/policies/series.js

@@ -27,11 +27,13 @@ export function resolveSeriesLayoutDomain({
       seriesLayouts[index] === undefined &&
       !isSourceOwnedText(consumer.layer)
   );
+  const layout = activeLayouts[0].layout;
   const compatibleDirect = directConsumers.every(({ consumer }) =>
     layoutConsumers.every(({ consumer: layoutConsumer }) => {
       const aggregate = layoutConsumer.encoding.aggregate;
       const directEncoding = consumer.encoding;
       return directEncoding.fieldType === "quantitative" && (
+        layout === "overlay" ||
         Object.hasOwn(directEncoding, "datum") ||
         (
           aggregate !== "count" &&
@@ -45,7 +47,6 @@ export function resolveSeriesLayoutDomain({
       `Series layout scale "${id}" cannot be shared with another policy.`
     );
   }
-  const layout = activeLayouts[0].layout;
   const values = [
     ...activeLayouts.flatMap(item => item.values),
     ...directConsumers.flatMap(item => item.values)