ggaction 0.0.12 → 0.0.15

package/src/materialization/coordinateBounds.js

@@ -0,0 +1,204 @@
+import { isSourceOwnedText } from "../grammar/text.js";
+import { resolvePolarFrame } from "../grammar/polar.js";
+import { resolveEffectiveBounds } from "../layout/aspect.js";
+import { resolveGraphicBounds } from "../layout/canvas.js";
+import { findCoordinate, requireCoordinate } from "../selectors/coordinates.js";
+import { findSemanticScale } from "../selectors/scales.js";
+
+const DATA_CHANNELS = Object.freeze(["x", "y"]);
+const SECONDARY_CHANNELS = Object.freeze({ x2: "x", y2: "y" });
+
+function samePair(left, right) {
+  return left.x === right.x && left.y === right.y;
+}
+
+export function resolveDataAspectScalePair(program, target) {
+  const coordinate = typeof target === "string"
+    ? requireCoordinate(program, target)
+    : target;
+  if (coordinate.type !== "cartesian") {
+    throw new Error("Coordinate data aspect requires a Cartesian coordinate.");
+  }
+  const layers = program.semanticSpec.layers.filter(layer =>
+    layer.coordinate === coordinate.id &&
+    !isSourceOwnedText(layer) &&
+    DATA_CHANNELS.some(channel => layer.encoding?.[channel] !== undefined)
+  );
+  if (layers.length === 0) {
+    throw new Error(
+      `Coordinate "${coordinate.id}" data aspect requires active x and y consumers.`
+    );
+  }
+  const pairs = layers.map(layer => {
+    for (const channel of DATA_CHANNELS) {
+      const encoding = layer.encoding?.[channel];
+      if (
+        encoding?.scale === undefined ||
+        encoding.fieldType !== "quantitative"
+      ) {
+        throw new Error(
+          `Coordinate "${coordinate.id}" data aspect requires quantitative x and y scale consumers.`
+        );
+      }
+    }
+    for (const [secondary, primary] of Object.entries(SECONDARY_CHANNELS)) {
+      const encoding = layer.encoding?.[secondary];
+      if (encoding !== undefined && (
+        encoding.fieldType !== "quantitative" ||
+        encoding.scale !== layer.encoding[primary].scale
+      )) {
+        throw new Error(
+          `Coordinate "${coordinate.id}" data aspect requires ${secondary} to share its quantitative ${primary} scale.`
+        );
+      }
+    }
+    return { x: layer.encoding.x.scale, y: layer.encoding.y.scale };
+  });
+  if (pairs.some(pair => !samePair(pair, pairs[0]))) {
+    throw new Error(
+      `Coordinate "${coordinate.id}" data aspect requires one consistent x/y scale pair.`
+    );
+  }
+  const scales = {
+    x: findSemanticScale(program, pairs[0].x),
+    y: findSemanticScale(program, pairs[0].y)
+  };
+  for (const channel of DATA_CHANNELS) {
+    if (scales[channel]?.type !== "linear") {
+      throw new Error(
+        `Coordinate data aspect requires a linear ${channel} scale.`
+      );
+    }
+  }
+  return Object.freeze({
+    x: pairs[0].x,
+    y: pairs[0].y
+  });
+}
+
+export function findDataAspectCoordinatesForScale(program, scaleId) {
+  return program.semanticSpec.coordinates.filter(coordinate => {
+    if (coordinate.aspect?.mode !== "data") return false;
+    const pair = resolveDataAspectScalePair(program, coordinate);
+    return pair.x === scaleId || pair.y === scaleId;
+  });
+}
+
+function sameNumericPair(left, right) {
+  return Array.isArray(left) && left.length === 2 &&
+    left.every((value, index) => Number.isFinite(value) &&
+      Math.abs(value - right[index]) <= 1e-9);
+}
+
+function validateExplicitDataRanges(program, pair, bounds) {
+  const expected = {
+    x: [bounds.x, bounds.x + bounds.width],
+    y: [bounds.y + bounds.height, bounds.y]
+  };
+  for (const channel of DATA_CHANNELS) {
+    const scale = findSemanticScale(program, pair[channel]);
+    if (scale.range === "auto") continue;
+    const directed = scale.reverse === true
+      ? [...expected[channel]].reverse()
+      : expected[channel];
+    if (!sameNumericPair(scale.range, directed)) {
+      throw new Error(
+        `Coordinate data aspect conflicts with explicit ${channel} scale range "${scale.id}".`
+      );
+    }
+  }
+}
+
+export function resolveCoordinateBounds(program, target, {
+  resolvedScales = program.resolvedScales
+} = {}) {
+  const allocated = resolveGraphicBounds(program);
+  if (target === undefined) return allocated;
+  const coordinate = requireCoordinate(program, target);
+  const aspect = coordinate.aspect;
+  if (aspect === undefined || aspect === "auto") return allocated;
+  if (aspect.mode !== "data") {
+    return resolveEffectiveBounds(allocated, aspect);
+  }
+  const pair = resolveDataAspectScalePair(program, coordinate);
+  const x = resolvedScales[pair.x];
+  const y = resolvedScales[pair.y];
+  if (x?.type !== "linear" || y?.type !== "linear") {
+    throw new Error(
+      `Coordinate "${coordinate.id}" data aspect requires resolved linear x and y scales.`
+    );
+  }
+  const bounds = resolveEffectiveBounds(allocated, aspect, {
+    x: x.domain,
+    y: y.domain
+  });
+  validateExplicitDataRanges(program, pair, bounds);
+  return bounds;
+}
+
+export function resolveCoordinatePolarFrame(program, target, options) {
+  const coordinate = requireCoordinate(program, target);
+  if (coordinate.type !== "polar") {
+    throw new Error(`Coordinate "${coordinate.id}" is not Polar.`);
+  }
+  return resolvePolarFrame(
+    resolveCoordinateBounds(program, coordinate.id, options),
+    coordinate.polarFrame
+  );
+}
+
+function consumerCoordinateIds(consumers) {
+  return [...new Set(consumers.map(consumer => consumer.layer.coordinate))];
+}
+
+function sameBounds(left, right) {
+  return ["x", "y", "width", "height"].every(
+    property => Math.abs(left[property] - right[property]) <= 1e-9
+  );
+}
+
+export function resolveScaleConsumerBounds(program, consumers, options) {
+  const coordinateIds = consumerCoordinateIds(consumers);
+  if (coordinateIds.length === 0) return resolveGraphicBounds(program);
+  const allocated = resolveGraphicBounds(program);
+  const bounds = coordinateIds.map(id =>
+    id === undefined || findCoordinate(program, id) === undefined
+      ? allocated
+      : resolveCoordinateBounds(program, id, options)
+  );
+  if (bounds.slice(1).some(candidate => !sameBounds(candidate, bounds[0]))) {
+    throw new Error(
+      "A position scale cannot be shared across coordinates with different effective bounds."
+    );
+  }
+  return bounds[0];
+}
+
+export function resolveGuideCoordinateBounds(program, {
+  coordinate,
+  scale,
+  channel,
+  resolvedScales = program.resolvedScales
+}) {
+  let target = coordinate;
+  if (target === undefined && scale !== undefined) {
+    const candidates = new Set();
+    for (const layer of program.semanticSpec.layers) {
+      if (isSourceOwnedText(layer)) continue;
+      if (layer.encoding?.[channel]?.scale === scale) {
+        candidates.add(layer.coordinate);
+      }
+    }
+    if (candidates.has(undefined)) {
+      throw new Error("Guide scale consumers require stored coordinates.");
+    }
+    if (candidates.size > 1) {
+      throw new Error("Guide bounds found no unique compatible coordinate.");
+    }
+    target = candidates.values().next().value;
+  }
+  if (target !== undefined && findCoordinate(program, target) === undefined) {
+    throw new Error(`Unknown coordinate "${target}".`);
+  }
+  return resolveCoordinateBounds(program, target, { resolvedScales });
+}

package/src/materialization/dependencies.js

@@ -1,12 +1,16 @@
+import { withGuideLayoutTransaction } from "./guides/layout.js";
 import {
   canDeferScaleConsumerApplication,
+  getLayerScaleIds,
   getExistingMarkRematerializationStep,
   getMarkMaterializationStep,
-  getSourceDependentMarkSteps
+  getScaleConsumerMarkSteps,
+  getSourceDependentMarkSteps,
+  reusePlannedMarkScales
 } from "./marks/index.js";
-import { requireLayer } from "../selectors/layers.js";
+import { findLayer, requireLayer } from "../selectors/layers.js";
 import {
-  applyMaterializationPlan,
+  applyMaterializationPlan as executeMaterializationPlan,
   buildMaterializationPlan
 } from "./planner.js";
 import { hasMaterializedLegend } from "./legends.js";
@@ -15,13 +19,7 @@ import {
   planScaleGuideRematerialization
 } from "./scaleGuideDependencies.js";
 import { planLayoutRematerialization } from "./layout.js";
-
-function layerScaleIds(layer) {
-  return [
-    ...Object.values(layer.encoding ?? {}).map(encoding => encoding?.scale),
-    ...(layer.encoding?.parallel?.dimensions ?? []).map(dimension => dimension.scale)
-  ].filter(scale => scale !== undefined);
-}
+import { requireCoordinate } from "../selectors/coordinates.js";
 
 export function planCanvasRematerialization(program) {
   const marks = [];
@@ -38,7 +36,7 @@ export function planCanvasRematerialization(program) {
     if (needsCanvasScaleRematerialization(program, scale)) {
       const deferredConsumers = program.semanticSpec.layers.filter(layer =>
         canDeferScaleConsumerApplication(layer) &&
-        layerScaleIds(layer).includes(scale.id)
+        getLayerScaleIds(layer).includes(scale.id)
       );
       const canDeferMarks = deferredConsumers.length === 0 ||
         deferredConsumers.every(layer => deferredMarkIds.has(layer.id));
@@ -64,9 +62,44 @@ export function planCanvasRematerialization(program) {
   return buildMaterializationPlan({ scales, marks, guides, layout });
 }
 
+export function planCoordinateRematerialization(program, target) {
+  requireCoordinate(program, target);
+  const layers = program.semanticSpec.layers.filter(
+    layer => layer.coordinate === target
+  );
+  const scaleIds = [...new Set(layers.flatMap(layer => [
+    ...["x", "y", "x2", "y2", "theta", "radius"].map(
+      channel => layer.encoding?.[channel]?.scale
+    ),
+    ...(layer.encoding?.parallel?.dimensions ?? []).map(
+      dimension => dimension.scale
+    )
+  ]).filter(id => id !== undefined))];
+  const directMarks = layers
+    .map(layer => getMarkMaterializationStep(program, layer))
+    .filter(step => step !== undefined);
+  const marks = [
+    ...directMarks,
+    ...directMarks.flatMap(step =>
+      getSourceDependentMarkSteps(program, step.args.id)
+    )
+  ];
+  return buildMaterializationPlan({
+    scales: scaleIds.map(id => ({
+      op: "rematerializeScale",
+      args: { id, guides: false, marks: false }
+    })),
+    marks: reusePlannedMarkScales(program, marks, scaleIds),
+    guides: scaleIds.flatMap(id =>
+      planScaleGuideRematerialization(program, id)
+    ),
+    layout: planLayoutRematerialization(program)
+  });
+}
+
 export function planLayerDataRematerialization(program, id) {
   const layer = requireLayer(program, id);
-  const scaleIds = [...new Set(layerScaleIds(layer))];
+  const scaleIds = [...new Set(getLayerScaleIds(layer))];
   const markStep = getMarkMaterializationStep(program, layer);
   const scales = scaleIds.map(scale => ({
       op: "rematerializeScale",
@@ -76,15 +109,19 @@ export function planLayerDataRematerialization(program, id) {
         ...(markStep === undefined ? {} : { marks: false })
       }
     }));
-  const marks = [
+  const directMarks = [
     ...(markStep === undefined ? [] : [markStep]),
-    ...getSourceDependentMarkSteps(program, id)
+    ...getScaleConsumerMarkSteps(program, scaleIds)
+  ];
+  const marks = [
+    ...directMarks,
+    ...directMarks.flatMap(step => getSourceDependentMarkSteps(program, step.args.id))
   ];
   if (scales.length > 0 || marks.length > 0) {
     const guides = scaleIds.flatMap(scale =>
       planScaleGuideRematerialization(program, scale)
     );
-    return buildMaterializationPlan({ scales, marks, guides });
+    return buildMaterializationPlan({ scales, marks: reusePlannedMarkScales(program, marks, scaleIds), guides });
   }
   const existingStep = getExistingMarkRematerializationStep(program, layer);
   return buildMaterializationPlan({
@@ -99,5 +136,45 @@ export function applyLayerDataRematerialization(program, id) {
   );
 }
 
-export { applyMaterializationPlan } from "./planner.js";
+export function applyLayerEmptyDataView(program, id) {
+  requireLayer(program, id);
+  const targets = [
+    id,
+    ...getSourceDependentMarkSteps(program, id).map(step => step.args.id)
+  ];
+  let next = program;
+  for (const target of new Set(targets)) {
+    const graphic = next.graphicSpec.objects[target];
+    if (graphic === undefined) continue;
+    next = graphic.type === "collection"
+      ? next.editGraphics({ target, property: "items", value: [] })
+      : next.editGraphics({ target, property: "length", value: 0 });
+  }
+  return next;
+}
+
+export function applyDetachedScaleRematerialization(program, previousLayers) {
+  const retained = new Set(program.semanticSpec.layers.flatMap(getLayerScaleIds));
+  const scaleIds = [...new Set(previousLayers.flatMap(layer => {
+    const current = findLayer(program, layer.id);
+    const currentIds = current === undefined ? [] : getLayerScaleIds(current);
+    return getLayerScaleIds(layer).filter(id => !currentIds.includes(id) && retained.has(id));
+  }))];
+  if (scaleIds.length === 0) return program;
+  const directMarks = getScaleConsumerMarkSteps(program, scaleIds);
+  return applyMaterializationPlan(program, buildMaterializationPlan({
+    scales: scaleIds.map(id => ({
+      op: "rematerializeScale", args: { id, guides: false, marks: false }
+    })),
+    marks: [
+      ...directMarks,
+      ...directMarks.flatMap(step => getSourceDependentMarkSteps(program, step.args.id))
+    ],
+    guides: scaleIds.flatMap(id => planScaleGuideRematerialization(program, id))
+  }));
+}
+
+export function applyMaterializationPlan(program, plan) {
+  return withGuideLayoutTransaction(program, next => executeMaterializationPlan(next, plan));
+}
 export { planScaleGuideRematerialization };

package/src/materialization/encodings.js

@@ -25,7 +25,7 @@ export function planEncodingRematerialization(program, {
   );
   const marks = [
     ...directMarks,
-    ...getSourceDependentMarkSteps(program, target)
+    ...directMarks.flatMap(step => getSourceDependentMarkSteps(program, step.args.id))
   ];
 
   const guides = [];

package/src/materialization/facetGuides/legacyCategorical.js

@@ -29,6 +29,9 @@ function collection(program, id, items) {
 }
 
 export function resolveLegacyCategoricalLegend(program) {
+  if (program.semanticSpec.layers.some(layer =>
+    layer.encoding?.stroke?.scale !== undefined
+  )) return undefined;
   const encodings = program.semanticSpec.layers.flatMap(layer =>
     layer.encoding?.color === undefined
       ? []

package/src/materialization/facetGuides/placement.js

@@ -46,10 +46,16 @@ function legendTranslation(prepared, plot, layout) {
       y: layout.legend.y - prepared.bounds.top
     };
   }
-  const strips = prepared.source.graphicSpec.objects.colorGradientStrips;
+  const gradientKind = prepared.kinds?.find(kind =>
+    ["gradient", "strokeGradient"].includes(kind)
+  );
+  const prefix = gradientKind === "strokeGradient"
+    ? "strokeGradient"
+    : "colorGradient";
+  const strips = prepared.source.graphicSpec.objects[`${prefix}Strips`];
   if (strips?.items?.[0] !== undefined) {
     const properties = strips.items[0].properties;
-    const length = prepared.source.guideConfigs.legend.gradient.gradient.length;
+    const length = prepared.source.guideConfigs.legend[gradientKind].gradient.length;
     return {
       x: layout.legend.x - (position === "left"
         ? prepared.bounds.left

package/src/materialization/facetGuides/preparation.js

@@ -35,7 +35,7 @@ function legendCandidates(program) {
     const layer = color[0];
     return {
       target: layer.id,
-      channels: ["color", "shape", "strokeDash"].filter(
+      channels: ["color", "stroke", "shape", "strokeDash"].filter(
         channel => layer.encoding?.[channel]?.scale !== undefined
       )
     };
@@ -45,7 +45,7 @@ function legendCandidates(program) {
       "Shared facet legend requires one unambiguous color legend target."
     );
   }
-  for (const channel of ["shape", "strokeDash", "size", "opacity"]) {
+  for (const channel of ["stroke", "shape", "strokeDash", "size", "opacity"]) {
     const candidates = layers.filter(
       layer => layer.encoding?.[channel]?.scale !== undefined
     );
@@ -105,9 +105,14 @@ function prepareAutoLegendSource(child) {
   }
   const scale = findSemanticScale(
     source,
-    findLayer(source, request.target)?.encoding?.color?.scale
+    findLayer(source, request.target)?.encoding?.[
+      request.channels.includes("color") ? "color" : "stroke"
+    ]?.scale
   );
   const gradient = scale?.type === "sequential";
+  const gradientPrefix = request.channels.includes("color")
+    ? "colorGradient"
+    : "strokeGradient";
   source = source.createLegend({
     target: request.target,
     channels: request.channels,
@@ -122,7 +127,7 @@ function prepareAutoLegendSource(child) {
     const resolved = source.resolvedScales[scale.id];
     source = source
       .editGraphics({
-        target: "colorGradientLabels",
+        target: `${gradientPrefix}Labels`,
         property: "text",
         value: formatDistinctNumericSamples(
           continuousValues(resolved.domain, 5),
@@ -130,9 +135,9 @@ function prepareAutoLegendSource(child) {
         )
       })
       .editGraphics({
-        target: "colorGradientTitle",
+        target: `${gradientPrefix}Title`,
         property: "y",
-        value: source.graphicSpec.objects.colorGradientTitle.properties.y + 8
+        value: source.graphicSpec.objects[`${gradientPrefix}Title`].properties.y + 8
       });
   }
   return source;
@@ -196,7 +201,7 @@ export function prepareSharedFacetLegend(program) {
   if (bounds === undefined) {
     throw new Error("Shared facet legend has no measurable concrete bounds.");
   }
-  const gradient = kinds.includes("gradient");
+  const gradient = kinds.some(kind => ["gradient", "strokeGradient"].includes(kind));
   const placement = promotedLegendPlacement(source, kinds);
   const width = Math.ceil(bounds.right - bounds.left);
   return {