ggaction 0.0.17 → 0.0.19

package/src/actions/guides/legends/focused.js

@@ -4,11 +4,11 @@ import { validateOptionObject } from "../../../core/validation.js";
 function makeFocusedLegendEdit({ name, options, map }) {
   return action(
     {
-      op: name,
+      op: name, scope: "any",
       description: `Edit one focused legend component through editLegend.`
     },
     function (args = {}) {
-      validateOptionObject(args, ["target", ...options], name);
+      validateOptionObject(args, ["target", "channel", ...options], name);
       if (!options.some(option => Object.hasOwn(args, option))) {
         throw new Error(`${name} requires at least one component change.`);
       }
@@ -20,7 +20,7 @@ function makeFocusedLegendEdit({ name, options, map }) {
 const editLegendLayout = /* @__PURE__ */ makeFocusedLegendEdit({
   name: "editLegendLayout",
   options: [
-    "position", "layout", "align", "direction", "columns", "offset",
+    "position", "layout", "align", "direction", "columns", "offset", "blockLayout", "at",
     "titlePosition", "itemGap"
   ],
   map: args => args
@@ -29,14 +29,15 @@ const editLegendLayout = /* @__PURE__ */ makeFocusedLegendEdit({
 const editLegendLabels = /* @__PURE__ */ makeFocusedLegendEdit({
   name: "editLegendLabels",
   options: ["offset", "color", "fontSize", "fontFamily", "fontWeight", "format"],
-  map: ({ target, ...labels }) => ({ target, labels })
+  map: ({ target, channel, ...labels }) => ({ target, ...(channel === undefined ? {} : { channel }), labels })
 });
 
 const editLegendTitle = /* @__PURE__ */ makeFocusedLegendEdit({
   name: "editLegendTitle",
-  options: ["title", "color", "fontSize", "fontFamily", "fontWeight"],
-  map: ({ target, title, ...titleStyle }) => ({
+  options: ["title", "color", "fontSize", "fontFamily", "fontWeight", "align"],
+  map: ({ target, channel, title, ...titleStyle }) => ({
     target,
+    ...(channel === undefined ? {} : { channel }),
     ...(title === undefined ? {} : { title }),
     ...(Object.keys(titleStyle).length === 0 ? {} : { titleStyle })
   })
@@ -44,7 +45,7 @@ const editLegendTitle = /* @__PURE__ */ makeFocusedLegendEdit({
 
 const editLegendSymbols = /* @__PURE__ */ makeFocusedLegendEdit({
   name: "editLegendSymbols",
-  options: ["symbol", "count", "gradient"],
+  options: ["symbol", "count", "gradient", "clipHeight"],
   map: args => args
 });
 

package/src/actions/guides/legends/group.js

@@ -0,0 +1 @@
+import{legendResourcePolicy as O}from"../../../materialization/guides/resources.js";import{LEGEND_POSITIONS as E,LEGEND_BLOCK_LAYOUTS as x}from"../../../core/vocabulary.js";import{validateLegendGroupState as v}from"../../../grammar/legendGroups.js";import{validateOptionObject as G,validateNonNegativeFinite as C}from"../../../core/validation.js";import{PLOT_LEGEND_POSITIONS as m}from"../../../layout/legend.js";import{legendGroup as _}from"../../../materialization/legendGroups.js";const N=E;function j(n){if(Object.hasOwn(n,"at")){if(G(n.at,["x","y"],"Legend at"),!Number.isFinite(n.at.x)||!Number.isFinite(n.at.y))throw new TypeError("Legend at requires finite x and y coordinates.");if(["position","align","offset"].some(e=>Object.hasOwn(n,e)))throw new Error("Legend at conflicts with position, align and offset in the same call.")}if(Object.hasOwn(n,"blockLayout")&&!x.includes(n.blockLayout))throw new Error("Legend blockLayout must be row, column or wrap.")}function y(n,e){return n.at!==void 0||e.at!==void 0?n.at!==void 0&&e.at!==void 0&&n.at.x===e.at.x&&n.at.y===e.at.y:n.position===e.position&&n.align===e.align&&n.offset===e.offset}function P(n,e,r,{creation:u=!1,corner:f=!1,nativeOffset:o=30}={}){j(e);const t=_(n,r),s=t!==void 0||e.at!==void 0||e.blockLayout!==void 0||f,{at:p,blockLayout:a,...l}=e;if(!s)return{program:n,options:l,grouped:!1};const g=Object.entries(n.guideConfigs.legend??{}).filter(([,d])=>d.target===r),w=g.map(([,d])=>d),h=g.find(([d])=>["series","color","stroke"].includes(d))?.[1].offset??o;if(w.some(d=>d.layout==="legacy-bottom")||e.layout==="legacy-bottom")throw new Error("Legend groups require edge layout.");let i;if(e.at!==void 0)i={at:{...e.at}};else if(e.position!==void 0){if(!N.includes(e.position))throw new Error(`Unsupported legend position "${e.position}".`);const d=m.includes(e.position),c=t?.placement.position===e.position;i={position:e.position,align:e.align??(c?t.placement.align:"center"),offset:e.offset??(c?t.placement.offset:d?8:h)}}else if(t!==void 0){if(i=t.placement.at===void 0?{...t.placement,...e.align===void 0?{}:{align:e.align},...e.offset===void 0?{}:{offset:e.offset}}:t.placement,t.placement.at!==void 0&&(e.align!==void 0||e.offset!==void 0))throw new Error("Free legend placement requires position before align or offset.")}else{const d=w.map(c=>({position:c.position,align:c.align,offset:c.offset}));if(d.length>1&&!d.every(c=>y(c,d[0])))throw new Error("Legend blockLayout requires an explicit anchor when existing blocks disagree.");i=d[0]??{position:"right",align:"center",offset:h}}if(i.position!==void 0){if(!["left","center","right"].includes(i.align))throw new Error("Unsupported legend group alignment.");if((m.includes(i.position)||["left","right"].includes(i.position))&&i.align!=="center")throw new Error("Side and in-plot legend groups require center alignment.");C(i.offset,"Legend group offset")}if(u&&t!==void 0&&(e.at!==void 0||e.position!==void 0||e.align!==void 0||e.offset!==void 0)&&!y(i,t.placement))throw new Error("New legend block anchor conflicts with its target group.");if(u&&t!==void 0&&e.blockLayout!==void 0&&e.blockLayout!==t.blockLayout)throw new Error("New legend blockLayout conflicts with its target group.");const b=e.blockLayout??t?.blockLayout??(i.at!==void 0?"column":m.includes(i.position)?"row":"wrap"),L={placement:i,blockLayout:b};v({[r]:L});const k=n._withMaterializationConfig(["guides","legendGroups",r],L);return i.position!==void 0&&(l.position=i.position,l.offset=i.offset,l.align=i.align),{program:k,options:l,grouped:!0}}function K(n,e){if(e.target!==void 0)return e.target;const r=e.channels,u=n.semanticSpec.layers.filter(f=>r===void 0?Object.keys(f.encoding??{}).some(o=>["color","stroke","shape","strokeDash","size","opacity","strokeWidth"].includes(o)&&f.encoding[o]?.scale!==void 0):r.every(o=>f.encoding?.[o]?.scale!==void 0));if(u.length!==1)throw new Error("Legend group requires one eligible target or an explicit target.");return u[0].id}function M(n,e,r,{creation:u=!1}={}){let f=e;for(const[o,t]of Object.entries(e.guideConfigs.legend??{})){const s=n.guideConfigs.legend?.[o];if(u&&s!==void 0||!u&&t===s)continue;const p=s??Object.entries(n.guideConfigs.legend??{}).find(([l,g])=>g.target===t.target&&O(l).semanticKind===O(o).semanticKind)?.[1],a=r.offset!==void 0?!1:u?!0:p?.inferredOffset===!0;f=f._withLegendConfig(o,{...t,inferredOffset:a})}for(const[o,t]of Object.entries(e.guideConfigs.legendGroups??{})){if(t.placement.at!==void 0){if(t.inferredOffset!==void 0){const{inferredOffset:a,...l}=t;f=f._withMaterializationConfig(["guides","legendGroups",o],l)}continue}const s=n.guideConfigs.legendGroups?.[o];if(t===s)continue;const p=r.offset!==void 0?!1:s?.placement.at!==void 0?!0:s!==void 0?s.inferredOffset===!0:Object.values(f.guideConfigs.legend??{}).filter(a=>a.target===o).every(a=>a.inferredOffset===!0);f=f._withMaterializationConfig(["guides","legendGroups",o],{...t,inferredOffset:p})}return f}export{K as creationLegendTarget,P as prepareLegendGroup,M as recordLegendOffsetIntent,j as validateLegendGroupOptions};

package/src/actions/guides/legends/lane.js

@@ -1,516 +1 @@
-import { editLegendBackground, resolveLegendBackgroundFromBounds } from "./continuous/common.js";
-import { action } from "../../../core/action.js";
-import { noOptions } from "../../../core/validation.js";
-import {
-  resolveConcreteGraphicBounds,
-  unionConcreteGraphicBounds
-} from "../../../grammar/schemas/graphicBounds.js";
-import { finiteMidpoint } from "../../../grammar/numeric.js";
-import { resolveGraphicBounds } from "../../../layout/canvas.js";
-import {
-  resolveHorizontalLegendLane,
-  resolveHorizontalLegendGroup,
-  resolveSingleHorizontalLegendPlacement,
-  isHorizontalEdgeLegend,
-  resolveSideLegendLane
-} from "../../../layout/legendLane.js";
-import { findCanvasGraphic } from
-  "../../../materialization/graphicHierarchy.js";
-import { legendResourcePolicy } from
-  "../../../materialization/guides/resources.js";
-
-const FAMILY_ORDER = Object.freeze({
-  series: 0,
-  color: 0,
-  stroke: 0,
-  gradient: 0,
-  interval: 0,
-  strokeGradient: 0,
-  strokeInterval: 0,
-  size: 1,
-  opacity: 2,
-  strokeWidth: 3
-});
-
-function categoricalFor(program, target) {
-  return ["series", "color", "stroke"]
-    .map(kind => program.guideConfigs.legend?.[kind])
-    .find(config => config?.target === target);
-}
-
-function legendPosition(program, kind, config) {
-  if (kind === "size") {
-    return categoricalFor(program, config.target)?.position ?? config.position;
-  }
-  return config.position;
-}
-
-function requestedOffset(config) {
-  return config.offset;
-}
-
-function existingIds(program, kind) {
-  return legendResourcePolicy(kind).graphicIds.filter(
-    id => program.graphicSpec.objects[id] !== undefined
-  );
-}
-
-function componentIds(program, kind) {
-  const ids = existingIds(program, kind);
-  const titleId = ids.find(id => id.endsWith("Title"));
-  const labelId = ids.find(id => id.endsWith("Labels"));
-  const backgroundId = ids.find(id => id.endsWith("Background"));
-  const symbolIds = ids.filter(id =>
-    id !== titleId && id !== labelId && id !== backgroundId
-  );
-  return { titleId, labelId, backgroundId, symbolIds };
-}
-
-function legendGraphicBounds(program, id) {
-  let bounds = resolveConcreteGraphicBounds(program.graphicSpec, id, program.materializationConfigs.textMetrics);
-  const graphic = program.graphicSpec.objects[id];
-  if (!id.includes("LegendSymbol") || graphic?.type !== "line") return bounds;
-  const properties = graphic.items?.map(item => item.properties) ??
-    [graphic.properties];
-  for (const item of properties) {
-    if (
-      Object.hasOwn(item, "lineCap") ||
-      typeof item.stroke !== "string" ||
-      !(item.strokeWidth > 0)
-    ) continue;
-    const extent = item.strokeWidth / 2;
-    bounds = {
-      left: Math.min(bounds.left, Math.min(item.x1, item.x2) - extent),
-      right: Math.max(bounds.right, Math.max(item.x1, item.x2) + extent),
-      top: Math.min(bounds.top, Math.min(item.y1, item.y2) - extent),
-      bottom: Math.max(bounds.bottom, Math.max(item.y1, item.y2) + extent)
-    };
-  }
-  return bounds;
-}
-
-function unionLegendBounds(program, ids) {
-  return ids.map(id => legendGraphicBounds(program, id))
-    .reduce((result, bounds) => result === undefined
-      ? bounds
-      : {
-          left: Math.min(result.left, bounds.left),
-          right: Math.max(result.right, bounds.right),
-          top: Math.min(result.top, bounds.top),
-          bottom: Math.max(result.bottom, bounds.bottom)
-        }, undefined);
-}
-
-function textAnchor(program, id) {
-  const graphic = program.graphicSpec.objects[id];
-  const properties = graphic.items?.[0]?.properties ?? graphic.properties;
-  return properties.x;
-}
-
-function blockDescriptor(program, kind, config) {
-  const components = componentIds(program, kind);
-  if (components.labelId === undefined || components.symbolIds.length === 0) {
-    throw new Error(`Legend lane requires complete ${kind} graphics.`);
-  }
-  const foregroundIds = [
-    ...components.symbolIds,
-    components.labelId,
-    ...(components.titleId === undefined ? [] : [components.titleId])
-  ];
-  const bounds = unionLegendBounds(program, foregroundIds);
-  const symbolAnchorIds = ["gradient", "strokeGradient"].includes(kind)
-    ? [kind === "gradient" ? "colorGradientStrips" : "strokeGradientStrips"]
-    : components.symbolIds;
-  const symbolAnchor = unionLegendBounds(program, symbolAnchorIds);
-  const symbolBounds = unionLegendBounds(program, components.symbolIds);
-  const labels = resolveConcreteGraphicBounds(
-    program.graphicSpec,
-    components.labelId
-  , program.materializationConfigs.textMetrics);
-  const title = components.titleId === undefined
-    ? undefined
-    : (() => {
-        const graphic = program.graphicSpec.objects[components.titleId];
-        const titleBounds = resolveConcreteGraphicBounds(
-          program.graphicSpec,
-          components.titleId
-        , program.materializationConfigs.textMetrics);
-        return {
-          x: graphic.properties.x,
-          y: graphic.properties.y,
-          fontSize: graphic.properties.fontSize,
-          width: titleBounds.right - titleBounds.left,
-          bounds: titleBounds
-        };
-      })();
-  if ([bounds, symbolAnchor, symbolBounds, labels].includes(undefined)) {
-    throw new Error(`Legend lane could not measure ${kind} graphics.`);
-  }
-  return {
-    id: kind,
-    kind,
-    target: config.target,
-    border: borderFor(kind, config),
-    offset: requestedOffset(config),
-    bounds,
-    title,
-    symbol: {
-      centerX: finiteMidpoint(symbolAnchor.left, symbolAnchor.right),
-      left: symbolBounds.left,
-      right: symbolBounds.right,
-      bounds: symbolAnchor
-    },
-    labels: {
-      x: textAnchor(program, components.labelId),
-      width: labels.right - labels.left
-    },
-    occupiedBounds: unionLegendBounds(program, [
-      ...foregroundIds,
-      ...(components.backgroundId === undefined ? [] : [components.backgroundId])
-    ]),
-    ...components,
-    foregroundIds
-  };
-}
-
-function borderFor(kind, config) {
-  return [
-    "series", "color", "stroke", "gradient", "strokeGradient", "opacity",
-    "interval", "strokeInterval", "strokeWidth", "size"
-  ].includes(kind)
-    ? config.border
-    : false;
-}
-
-function groupBlocks(blocks, configs) {
-  const groups = [];
-  for (let index = 0; index < blocks.length; index += 1) {
-    const block = blocks[index];
-    const config = configs[block.kind];
-    const next = blocks[index + 1];
-    if (
-      ["series", "color", "stroke"].includes(block.kind) &&
-      next?.kind === "size" && next.target === block.target
-    ) {
-      groups.push({
-        id: `${block.kind}+size`,
-        blocks: [block, next.backgroundId === undefined ? next : { ...next,
-          bounds: next.occupiedBounds, inset: next.border.padding + next.border.lineWidth / 2 }],
-        border: borderFor(block.kind, config),
-        backgroundId: block.backgroundId
-      });
-      index += 1;
-      continue;
-    }
-    groups.push({
-      id: block.kind,
-      blocks: [block],
-      border: borderFor(block.kind, config),
-      backgroundId: block.backgroundId
-    });
-  }
-  return groups;
-}
-
-function edgeKinds(program, edge) {
-  const configs = program.guideConfigs.legend ?? {};
-  const layerOrder = new Map(program.semanticSpec.layers.map(
-    (layer, index) => [layer.id, index]
-  ));
-  return Object.entries(configs)
-    .filter(([kind, config]) => legendPosition(program, kind, config) === edge)
-    .sort(([kindA, configA], [kindB, configB]) =>
-      (layerOrder.get(configA.target) - layerOrder.get(configB.target)) ||
-      (FAMILY_ORDER[kindA] - FAMILY_ORDER[kindB])
-    );
-}
-
-export function hasMultiSideLegendLane(program) {
-  return ["right", "left"].some(side => edgeKinds(program, side).length > 1);
-}
-
-export function hasHorizontalLegendLane(program) {
-  return ["top", "bottom"].some(edge => edgeKinds(program, edge).some(
-    ([, config]) => isHorizontalEdgeLegend({ ...config, position: edge })
-  ));
-}
-
-export function hasLegendLane(program) {
-  return hasMultiSideLegendLane(program) ||
-    hasHorizontalLegendLane(program);
-}
-
-function translateCommands(commands, dx, dy) {
-  return commands.map(command => {
-    if (command.op === "Z") return { ...command };
-    const next = {
-      ...command,
-      x: command.x + dx,
-      y: command.y + dy
-    };
-    if (command.op === "C") {
-      next.x1 = command.x1 + dx;
-      next.y1 = command.y1 + dy;
-      next.x2 = command.x2 + dx;
-      next.y2 = command.y2 + dy;
-    }
-    return next;
-  });
-}
-
-function translatedProperties(type, properties, dx, dy) {
-  const next = { ...properties };
-  if (["circle", "rect", "text"].includes(type)) {
-    next.x += dx;
-    next.y += dy;
-  } else if (type === "line") {
-    next.x1 += dx;
-    next.x2 += dx;
-    next.y1 += dy;
-    next.y2 += dy;
-  } else if (type === "path") {
-    next.commands = translateCommands(next.commands, dx, dy);
-  }
-  return next;
-}
-
-function translateGraphic(program, id, dx, dy) {
-  const graphic = program.graphicSpec.objects[id];
-  if (dx === 0 && dy === 0) return program;
-  if (graphic.items !== undefined) {
-    return program.editGraphics({
-      target: id,
-      property: "items",
-      value: graphic.items.map(item => ({
-        type: item.type ?? graphic.type,
-        properties: translatedProperties(
-          item.type ?? graphic.type,
-          item.properties,
-          dx,
-          dy
-        )
-      }))
-    });
-  }
-  let next = program;
-  const properties = translatedProperties(
-    graphic.type,
-    graphic.properties,
-    dx,
-    dy
-  );
-  for (const [property, value] of Object.entries(properties)) {
-    if (value !== graphic.properties[property]) {
-      next = next.editGraphics({ target: id, property, value });
-    }
-  }
-  return next;
-}
-
-function horizontalGroups(program, groups) {
-  return groups.map(group => {
-    const representative = group.blocks[0];
-    const config = program.guideConfigs.legend?.[representative.kind];
-    const atomic = group.blocks.length > 1;
-    const titleId = atomic ? undefined : representative.titleId;
-    const contentIds = group.blocks.flatMap(block => block.foregroundIds)
-      .filter(id => id !== titleId);
-    if (atomic) contentIds.push(...group.blocks.slice(1).flatMap(block =>
-      block.backgroundId === undefined ? [] : [block.backgroundId]));
-    const content = unionLegendBounds(program, contentIds);
-    const foreground = unionLegendBounds(
-      program,
-      [...contentIds, ...(titleId === undefined ? [] : [titleId])]
-    );
-    if (content === undefined || foreground === undefined) {
-      throw new Error(`Legend lane could not measure ${group.id} content.`);
-    }
-    const border = group.border;
-    const inset = border === false
-      ? 0
-      : border.padding + border.lineWidth / 2;
-    return {
-      id: group.id,
-      atomic,
-      titleId,
-      contentIds,
-      title: atomic ? undefined : representative.title,
-      inline: config?.titlePosition === "left",
-      element: atomic ? foreground : representative.symbol.bounds,
-      content,
-      horizontal: { left: foreground.left, right: foreground.right,
-        top: foreground.top, bottom: foreground.bottom },
-      inset,
-      padding: border === false ? 0 : border.padding,
-      backgroundId: group.backgroundId
-    };
-  });
-}
-
-function applyHorizontalPlan(program, groups, plan) {
-  let next = program;
-  const byId = new Map(groups.map(group => [group.id, group]));
-  for (const placement of plan.placements) {
-    const group = byId.get(placement.id);
-    if (group.titleId !== undefined) {
-      next = translateGraphic(next, group.titleId, placement.dx, placement.titleDy);
-    }
-    for (const id of group.contentIds) {
-      next = translateGraphic(next, id, placement.dx, placement.contentDy);
-    }
-    if (placement.background !== undefined) {
-      for (const property of ["x", "y", "width", "height"]) {
-        next = next.editGraphics({ target: placement.background.id, property,
-          value: placement.background[property] });
-      }
-    }
-  }
-  if (plan.background !== undefined) {
-    for (const property of ["x", "y", "width", "height"]) {
-      next = next.editGraphics({ target: plan.background.id, property,
-        value: plan.background[property] });
-    }
-  }
-  return next;
-}
-
-export const rematerializeSideLegendLane = /* @__PURE__ */ action(
-  {
-    op: "rematerializeSideLegendLane",
-    description: "Align and stack every right or left legend block."
-  },
-  function (args = {}) {
-    noOptions(args, "rematerializeSideLegendLane");
-    const plot = resolveGraphicBounds(this);
-    const canvas = findCanvasGraphic(this)?.properties;
-    if (plot === undefined || canvas === undefined) {
-      throw new Error("Legend lane requires resolved Canvas and plot bounds.");
-    }
-    const configs = this.guideConfigs.legend ?? {};
-    const plans = ["right", "left"].flatMap(side => {
-      const entries = edgeKinds(this, side);
-      if (entries.length < 2) return [];
-      const blocks = entries.map(([kind, config]) =>
-        blockDescriptor(this, kind, config)
-      );
-      const plan = resolveSideLegendLane({
-        side,
-        plot,
-        canvas,
-        groups: groupBlocks(blocks, configs)
-      });
-      return [{ plan, blocks }];
-    });
-    let next = this;
-    for (const { plan, blocks } of plans) {
-      const byId = new Map(blocks.map(block => [block.id, block]));
-      for (const placement of plan.placements) {
-        const block = byId.get(placement.id);
-        if (block.titleId !== undefined) {
-          next = translateGraphic(
-            next,
-            block.titleId,
-            placement.titleDx,
-            placement.dy
-          ).editGraphics({
-            target: block.titleId,
-            property: "textAlign",
-            value: "left"
-          });
-        }
-        for (const id of block.symbolIds) {
-          next = translateGraphic(
-            next,
-            id,
-            placement.symbolDx,
-            placement.dy
-          );
-        }
-        next = translateGraphic(
-          next,
-          block.labelId,
-          placement.labelDx,
-          placement.dy
-        ).editGraphics({
-          target: block.labelId,
-          property: "textAlign",
-          value: "left"
-        });
-      }
-      for (const block of blocks) {
-        if (block.backgroundId === undefined || plan.backgrounds.some(item => item.id === block.backgroundId)) continue;
-        const bounds = unionLegendBounds(next, block.foregroundIds);
-        const background = resolveLegendBackgroundFromBounds([bounds], block.border, canvas, "Legend");
-        next = editLegendBackground(next, block.backgroundId, background, block.border);
-      }
-      for (const background of plan.backgrounds) {
-        for (const property of ["x", "y", "width", "height"]) {
-          next = next.editGraphics({
-            target: background.id,
-            property,
-            value: background[property]
-          });
-        }
-      }
-    }
-    return next;
-  }
-);
-
-export const rematerializeHorizontalLegendLane = /* @__PURE__ */ action(
-  {
-    op: "rematerializeHorizontalLegendLane",
-    description: "Pack and align every top or bottom legend block."
-  },
-  function (args = {}) {
-    noOptions(args, "rematerializeHorizontalLegendLane");
-    const plot = resolveGraphicBounds(this);
-    const canvas = findCanvasGraphic(this)?.properties;
-    if (plot === undefined || canvas === undefined) {
-      throw new Error("Legend lane requires resolved Canvas and plot bounds.");
-    }
-    const configs = this.guideConfigs.legend ?? {};
-    let next = this;
-    for (const edge of ["top", "bottom"]) {
-      const entries = edgeKinds(next, edge).filter(
-        ([, config]) => isHorizontalEdgeLegend({ ...config, position: edge })
-      );
-      if (entries.length === 0) continue;
-      if (entries.length === 1) {
-        const [kind, config] = entries[0];
-        const ids = existingIds(next, kind);
-        const bounds = unionConcreteGraphicBounds(next.graphicSpec, ids, next.materializationConfigs.textMetrics);
-        const { dx, dy } = resolveSingleHorizontalLegendPlacement({
-          plot, canvas, config, bounds
-        });
-        for (const id of ids) next = translateGraphic(next, id, dx, dy);
-        continue;
-      }
-      let groups = groupBlocks(entries.map(([kind, config]) =>
-        blockDescriptor(next, kind, config)), configs);
-      for (const group of groups.filter(group => group.blocks.length > 1)) {
-        const config = configs[group.blocks[0].kind];
-        const children = horizontalGroups(next, group.blocks.map((block, index) => ({
-          id: block.id, blocks: [block], border: index === 0 ? false : block.border,
-          backgroundId: index === 0 ? undefined : block.backgroundId
-        }))).map(child => ({ ...child, element: child.content }));
-        const plan = resolveHorizontalLegendGroup({ edge, plot, canvas, groups: children,
-          align: config.align, offset: config.offset, border: group.border,
-          backgroundId: group.backgroundId });
-        next = applyHorizontalPlan(next, children, plan);
-      }
-      if (groups.length < 2) continue;
-      groups = groupBlocks(entries.map(([kind, config]) =>
-        blockDescriptor(next, kind, config)), configs);
-      const horizontal = horizontalGroups(next, groups);
-      const plan = resolveHorizontalLegendLane({
-        edge,
-        plot,
-        canvas,
-        groups: horizontal
-      });
-      next = applyHorizontalPlan(next, horizontal, plan);
-    }
-    return next;
-  }
-);
+import{translateGraphic as m}from"../../../materialization/graphicTranslation.js";import{editLegendBorderBounds as v}from"../../../materialization/legendBorder.js";import{resolveLegendAxisOffset as I,effectiveLegendOffsetConfig as F}from"../../../materialization/guides/resources.js";import{resolveLegendGroupPlacement as A}from"../../../layout/legendGroup.js";import{localLegendPosition as z,localLegendPlacement as $,legendGroup as R}from"../../../materialization/legendGroups.js";import{editLegendBackground as T,resolveLegendBackgroundFromBounds as K}from"./continuous/common.js";import{action as G}from"../../../core/action.js";import{noOptions as S}from"../../../core/validation.js";import{resolveConcreteGraphicBounds as M,unionConcreteGraphicBounds as H}from"../../../grammar/schemas/graphicBounds.js";import{finiteMidpoint as X}from"../../../grammar/numeric.js";import{resolveGraphicBounds as C}from"../../../layout/canvas.js";import{resolveHorizontalLegendLane as Y,resolveHorizontalLegendGroup as _,resolveSingleHorizontalLegendPlacement as W,isHorizontalEdgeLegend as D,resolveSideLegendLane as J,resolveSingleSideLegendPlacement as N}from"../../../layout/legendLane.js";import{findCanvasGraphic as w}from"../../../materialization/graphicHierarchy.js";import{legendResourcePolicy as Q}from"../../../materialization/guides/resources.js";const y=Object.freeze({colorSize:0,series:0,color:0,stroke:0,gradient:0,interval:0,strokeGradient:0,strokeInterval:0,size:1,opacity:2,strokeWidth:3});function U(r,n){return["series","color","stroke"].map(t=>r.guideConfigs.legend?.[t]).find(t=>t?.target===n)}function V(r,n,t){return n==="size"&&t.inheritPosition!==!1?U(r,t.target)?.position??t.position:t.position}function Z(r){return r.offset}function h(r,n){return Q(n).graphicIds.filter(t=>r.graphicSpec.objects[t]!==void 0)}function ee(r,n){const t=h(r,n),i=t.find(a=>a.endsWith("Title")),o=t.find(a=>a.endsWith("Labels")),e=t.find(a=>a.endsWith("Background")),s=t.filter(a=>a!==i&&a!==o&&a!==e);return{titleId:i,labelId:o,backgroundId:e,symbolIds:s}}function te(r,n){let t=M(r.graphicSpec,n,r.materializationConfigs.textMetrics);const i=r.graphicSpec.objects[n];if(!n.includes("LegendSymbol")||i?.type!=="line")return t;const o=i.items?.map(e=>e.properties)??[i.properties];for(const e of o){if(Object.hasOwn(e,"lineCap")||typeof e.stroke!="string"||!(e.strokeWidth>0))continue;const s=e.strokeWidth/2;t={left:Math.min(t.left,Math.min(e.x1,e.x2)-s),right:Math.max(t.right,Math.max(e.x1,e.x2)+s),top:Math.min(t.top,Math.min(e.y1,e.y2)-s),bottom:Math.max(t.bottom,Math.max(e.y1,e.y2)+s)}}return t}function b(r,n){return n.map(t=>te(r,t)).filter(t=>t!==void 0).reduce((t,i)=>t===void 0?i:{left:Math.min(t.left,i.left),right:Math.max(t.right,i.right),top:Math.min(t.top,i.top),bottom:Math.max(t.bottom,i.bottom)},void 0)}function ne(r,n){const t=r.graphicSpec.objects[n];return(t.items?.[0]?.properties??t.properties).x}function B(r,n,t){const i=ee(r,n);if(i.labelId===void 0||i.symbolIds.length===0)throw new Error(`Legend lane requires complete ${n} graphics.`);const o=[...i.symbolIds,i.labelId,...i.titleId===void 0?[]:[i.titleId]],e=b(r,o),s=["gradient","strokeGradient"].includes(n)&&t.representation!=="symbols"?[n==="gradient"?"colorGradientStrips":"strokeGradientStrips"]:i.symbolIds,a=b(r,s),f=b(r,i.symbolIds),u=M(r.graphicSpec,i.labelId,r.materializationConfigs.textMetrics),c=r.graphicSpec.objects[i.labelId].items?.length===0,d=i.titleId===void 0?void 0:(()=>{const g=r.graphicSpec.objects[i.titleId],p=M(r.graphicSpec,i.titleId,r.materializationConfigs.textMetrics);return{x:g.properties.x,y:g.properties.y,fontSize:g.properties.fontSize,width:p.right-p.left,bounds:p}})();if([e,a,f].includes(void 0)||u===void 0&&!c)throw new Error(`Legend lane could not measure ${n} graphics.`);const l=["gradient","strokeGradient"].includes(n)&&t.representation!=="symbols"&&(t.gradientDirection==="horizontal"||t.titlePosition==="bottom");return{id:n,kind:n,preserveAlignment:l,preserveGrid:l||(["series","color","stroke"].includes(n)||t.representation==="symbols")&&(t.columns??1)>1,target:t.target,border:O(n,t),offset:Z(t),bounds:e,title:d,symbol:{centerX:X(a.left,a.right),left:f.left,right:f.right,bounds:a},labels:{x:c?f.right+t.labels.offset:ne(r,i.labelId),width:c?0:u.right-u.left},occupiedBounds:b(r,[...o,...i.backgroundId===void 0?[]:[i.backgroundId]]),...i,foregroundIds:o}}function O(r,n){return["series","color","stroke","gradient","strokeGradient","opacity","interval","strokeInterval","strokeWidth","size","colorSize"].includes(r)?n.border:!1}function j(r,n){const t=[];for(let i=0;i<r.length;i+=1){const o=r[i],e=n[o.kind],s=r[i+1];if(["series","color","stroke"].includes(o.kind)&&s?.kind==="size"&&s.target===o.target){t.push({id:`${o.kind}+size`,blocks:[o,s.backgroundId===void 0?s:{...s,bounds:s.occupiedBounds,inset:s.border.padding+s.border.lineWidth/2}],border:O(o.kind,e),backgroundId:o.backgroundId}),i+=1;continue}t.push({id:o.kind,blocks:[o],border:O(o.kind,e),backgroundId:o.backgroundId})}return t}function x(r,n){const t=r.guideConfigs.legend??{},i=new Map(r.semanticSpec.layers.map((o,e)=>[o.id,e]));return Object.entries(t).filter(([o,e])=>z(e)===void 0&&R(r,e.target)===void 0&&V(r,o,e)===n).sort(([o,e],[s,a])=>i.get(e.target)-i.get(a.target)||y[o]-y[s])}function oe(r){return["right","left"].some(n=>x(r,n).length>0)}function ie(r){return["top","bottom"].some(n=>x(r,n).some(([,t])=>D({...t,position:n})))}function Ie(r){return Object.values(r.guideConfigs.legend??{}).some(n=>z(n)!==void 0)||oe(r)||ie(r)}function P(r,n){const t=o=>o.textBaseline==="middle"?{...o,y:o.y-o.fontSize/2,textBaseline:"top"}:o;let i=r;for(const o of n){const e=i.graphicSpec.objects[o];if(e.type==="text")if(e.items!==void 0){if(!e.items.some(s=>s.properties.textBaseline==="middle"))continue;i=i.editGraphics({target:o,property:"items",value:e.items.map(s=>({type:s.type??e.type,properties:t(s.properties)}))})}else e.properties.textBaseline==="middle"&&(i=i.editGraphics({target:o,property:"y",value:t(e.properties).y}).editGraphics({target:o,property:"textBaseline",value:"top"}))}return i}function E(r,n){return n.map(t=>{const i=t.blocks[0],o=r.guideConfigs.legend?.[i.kind],e=t.blocks.length>1,s=e?void 0:i.titleId,a=t.blocks.flatMap(l=>l.foregroundIds).filter(l=>l!==s);e&&a.push(...t.blocks.slice(1).flatMap(l=>l.backgroundId===void 0?[]:[l.backgroundId]));const f=b(r,a),u=b(r,[...a,...s===void 0?[]:[s]]);if(f===void 0||u===void 0)throw new Error(`Legend lane could not measure ${t.id} content.`);const c=t.border,d=c===!1?0:c.padding+c.lineWidth/2;return{id:t.id,atomic:e,titleId:s,contentIds:a,title:e?void 0:i.title,inline:o?.titlePosition==="left",element:e?u:i.symbol.bounds,content:f,horizontal:{left:u.left,right:u.right,top:u.top,bottom:u.bottom},inset:d,padding:c===!1?0:c.padding,backgroundId:t.backgroundId}})}function q(r,n,t){let i=r;const o=new Map(n.map(e=>[e.id,e]));for(const e of t.placements){const s=o.get(e.id);s.titleId!==void 0&&(i=m(i,s.titleId,e.dx,e.titleDy));for(const a of s.contentIds)i=m(i,a,e.dx,e.contentDy);e.background!==void 0&&(i=v(i,e.background.id,e.background))}return t.background!==void 0&&(i=v(i,t.background.id,t.background)),i}const ye=G({op:"rematerializeSideLegendLane",description:"Align and stack every right or left legend block."},function(r={}){if(S(r,"rematerializeSideLegendLane"),this.context.facetLegendIntrinsic===!0)return this;const n=C(this),t=w(this)?.properties;if(n===void 0||t===void 0)throw new Error("Legend lane requires resolved Canvas and plot bounds.");const i=this.guideConfigs.legend??{},o=["right","left"].flatMap(s=>{const a=x(this,s);if(a.length===0)return[];if(a.length===1)return[{side:s,entries:a}];const f=a.map(([c,d])=>B(this,c,d));return[{plan:J({side:s,plot:n,canvas:t,groups:j(f,i)}),blocks:f,side:s,entries:a}]});let e=this;for(const{plan:s,blocks:a,side:f,entries:u}of o){if(s===void 0)continue;const c=new Map(a.map(d=>[d.id,d]));for(const d of s.placements){const l=c.get(d.id);l.titleId!==void 0&&(e=m(e,l.titleId,d.titleDx,d.dy),l.preserveAlignment||(e=e.editGraphics({target:l.titleId,property:"textAlign",value:"left"})));for(const g of l.symbolIds)e=m(e,g,d.symbolDx,d.dy);e=m(e,l.labelId,d.labelDx,d.dy),l.preserveAlignment||(e=e.editGraphics({target:l.labelId,property:"textAlign",value:"left"}))}for(const d of a){if(d.backgroundId===void 0||s.backgrounds.some(p=>p.id===d.backgroundId))continue;const l=b(e,d.foregroundIds),g=K([l],d.border,t,"Legend");e=T(e,d.backgroundId,g,d.border)}for(const d of s.backgrounds)e=v(e,d.id,d)}for(const{side:s,entries:a}of o){const f=a.flatMap(([d])=>h(e,d));e=P(e,f);const u=b(e,f),{dy:c}=N({side:s,plot:n,canvas:t,bounds:u});for(const d of f)e=m(e,d,0,c)}return e}),xe=G({op:"rematerializeHorizontalLegendLane",description:"Pack and align every top or bottom legend block."},function(r={}){if(S(r,"rematerializeHorizontalLegendLane"),this.context.facetLegendIntrinsic===!0)return this;const n=C(this),t=w(this)?.properties;if(n===void 0||t===void 0)throw new Error("Legend lane requires resolved Canvas and plot bounds.");const i=this.guideConfigs.legend??{};let o=this;for(const e of["top","bottom"]){const s=x(o,e).filter(([,c])=>D({...c,position:e})).map(([c,d])=>[c,F(o,c,d)]);if(s.length===0)continue;if(s.length===1){const[c,d]=s[0],l=h(o,c),g=H(o.graphicSpec,l,o.materializationConfigs.textMetrics),{dx:p,dy:k}=W({plot:n,canvas:t,config:{...d,offset:I(o,d,n)},bounds:g});for(const L of l)o=m(o,L,p,k);continue}for(const[c,d]of s){if(d.inferredOffset!==!0||I(o,d,n)===d.offset)continue;const l=h(o,c),g=H(o.graphicSpec,l,o.materializationConfigs.textMetrics),{dx:p,dy:k}=W({plot:n,canvas:t,config:{...d,offset:I(o,d,n)},bounds:g});for(const L of l)o=m(o,L,p,k)}let a=j(s.map(([c,d])=>B(o,c,d)),i);for(const c of a.filter(d=>d.blocks.length>1)){const d=i[c.blocks[0].kind],l=E(o,c.blocks.map((p,k)=>({id:p.id,blocks:[p],border:k===0?!1:p.border,backgroundId:k===0?void 0:p.backgroundId}))).map(p=>({...p,element:p.content})),g=_({edge:e,plot:n,canvas:t,groups:l,allowOverflow:o.materializationConfigs.canvas?.plot!==void 0,align:d.align,offset:I(o,d,n),border:c.border,backgroundId:c.backgroundId});o=q(o,l,g)}if(a.length<2)continue;a=j(s.map(([c,d])=>B(o,c,d)),i);const f=E(o,a),u=Y({edge:e,plot:n,canvas:t,groups:f,allowOverflow:o.materializationConfigs.canvas?.plot!==void 0});o=q(o,f,u)}return o}),Le=G({op:"rematerializeLegendGroups",description:"Place each opted-in target legend group from occupied bounds."},function(r={}){if(S(r,"rematerializeLegendGroups"),this.context.facetLegendIntrinsic===!0)return this;let n=this;const t=C(n),i=w(n)?.properties;for(const[o,e]of Object.entries(n.guideConfigs.legendGroups??{})){const s=Object.entries(n.guideConfigs.legend??{}).filter(([,c])=>c.target===o&&z(c)===void 0).sort(([c],[d])=>y[c]-y[d]);n=P(n,s.flatMap(([c])=>h(n,c)));const a=s.map(([c])=>({id:c,ids:h(n,c),bounds:b(n,h(n,c))})),f=e.placement.at!==void 0?e:{...e,placement:{...e.placement,offset:I(n,{...e.placement,inferredOffset:e.inferredOffset},t)}},u=A({blocks:a,group:f,plot:t,canvas:i,allowOverflow:n.materializationConfigs.canvas?.plot!==void 0});for(const c of u){const d=a.find(l=>l.id===c.id);for(const l of d.ids)n=m(n,l,c.dx,c.dy)}}for(const[o,e]of Object.entries(n.guideConfigs.legend??{})){const s=$(e);if(s===void 0)continue;const a=h(n,o);n=P(n,a);const f={placement:{...s,offset:I(n,s,t)},blockLayout:"column"},[u]=A({blocks:[{id:o,bounds:b(n,a)}],group:f,plot:t,canvas:i,allowOverflow:n.materializationConfigs.canvas?.plot!==void 0});for(const c of a)n=m(n,c,u.dx,u.dy)}return n});export{ie as hasHorizontalLegendLane,Ie as hasLegendLane,oe as hasSideLegendLane,xe as rematerializeHorizontalLegendLane,Le as rematerializeLegendGroups,ye as rematerializeSideLegendLane};

package/src/actions/guides/legends/lifecycle.js

@@ -46,8 +46,9 @@ export function resolveCategoricalLegendRevision(program, kind, previous, channe
   const layer = findLayer(program, previous.target);
   const definition = resolveDefinition(program, layer, channels,
     previous.inferredTitle ? undefined : previous.title, order);
+  const {combine: _combine, sizeAreas: _areas, ...shared} = previous;
   const config = {
-    ...previous,
+    ...shared,
     ...definition,
     symbol: normalizeRecipe(resolveLegendSymbol(
       program,

package/src/actions/guides/legends/remove.js

@@ -1,3 +1,4 @@
+import { editFacetParentLegend } from "../../../materialization/facetGuides/edit.js";
 import { closedAction } from "../../../core/action.js";
 
 import {
@@ -15,6 +16,7 @@ const OPTIONS = Object.freeze(["target", "channels"]);
 function legendKindChannels(kind, config) {
   if (["series", "color", "stroke"].includes(kind)) return config.channels;
   return {
+    colorSize: ["color","size"],
     size: ["size"],
     gradient: ["color"],
     interval: ["color"],
@@ -38,7 +40,7 @@ function resolveRequestedRemoval(program, target, channels) {
     if (overlap.length === 0) continue;
     kinds.push(kind);
     for (const channel of overlap) matched.add(channel);
-    if (overlap.length !== owned.length) {
+    if (overlap.length !== owned.length && !["size-shape","color-size"].includes(config.combine)) {
       partial = { kind, config, channels: owned.filter(channel => !requested.has(channel)) };
     }
   }
@@ -62,14 +64,15 @@ function resolveRequestedRemoval(program, target, channels) {
 export function removeOwnedColorLegends(program, target) {
   const kinds = Object.entries(program.guideConfigs.legend ?? {})
     .filter(([kind, config]) => config?.target === target && (
-      config.channels?.includes("color") || ["gradient", "interval"].includes(kind)
+      config.channels?.includes("color") || ["gradient", "interval", "colorSize"].includes(kind)
     )).map(([kind]) => kind);
   return kinds.length === 0 ? program : removeLegendKinds(program, kinds);
 }
 
 export const removeLegend = /* @__PURE__ */ closedAction(
-  { op: "removeLegend", description: "Remove selected legend content or every block owned by one mark." }, OPTIONS,
+  { op: "removeLegend", description: "Remove selected legend content or every block owned by one mark.", scope: "any" }, OPTIONS,
   function (args = {}) {
+    if (this.compositionSpec !== undefined) return editFacetParentLegend(this, "removeLegend", args);
     const target = resolveLegendTarget(this, args.target, "removeLegend");
     const targetKinds = Object.entries(this.guideConfigs.legend ?? {})
       .filter(([, config]) => config?.target === target)
@@ -81,6 +84,9 @@ export const removeLegend = /* @__PURE__ */ closedAction(
     if (revision !== undefined) {
       next = createCategoricalLegendFromConfig(next, revision.config, revision.order);
     }
+    if (!Object.values(next.guideConfigs.legend ?? {}).some(config => config.target === target)) {
+      next = next._withoutMaterializationConfig(["guides", "legendGroups", target]);
+    }
     const retainedKinds = Object.keys(next.guideConfigs.legend ?? {});
     if (args.channels === undefined) {
       return retainedKinds.length === 0

package/src/actions/guides/legends/sampling.js

@@ -133,7 +133,7 @@ export function resolveLegendSampleValues(config, scale, label = "Legend") {
 }
 
 export function hasExactLegendSamplingForScale(program, scaleId) {
-  return ["size", "opacity", "strokeWidth"].some(kind => {
+  return ["size", "opacity", "strokeWidth", "gradient"].some(kind => {
     const config = program.guideConfigs.legend?.[kind];
     return config?.scale === scaleId && readLegendSampling(config).mode === "values";
   });