ggaction 0.0.9 → 0.0.11

package/src/grammar/schemas/graphicBounds.js

@@ -1,34 +1,99 @@
-import { resolveTextBounds } from "../../core/textMetrics.js";
-import { findGraphic, requireGraphic } from "./graphicTree.js";
+import {
+  requireFiniteBounds,
+  resolveTextBounds
+} from "../../core/textMetrics.js";
+import { interpolateNumber } from "../numeric.js";
+import {
+  findGraphic,
+  findGraphicParent,
+  requireGraphic
+} from "./graphicTree.js";
 
-function unionBounds(bounds) {
-  if (bounds.length === 0) return undefined;
+const EPSILON = Number.EPSILON * 64;
+
+function box(left, right, top, bottom, extent = 0) {
   return {
-    left: Math.min(...bounds.map(item => item.left)),
-    right: Math.max(...bounds.map(item => item.right)),
-    top: Math.min(...bounds.map(item => item.top)),
-    bottom: Math.max(...bounds.map(item => item.bottom))
+    left: left - extent,
+    right: right + extent,
+    top: top - extent,
+    bottom: bottom + extent
   };
 }
 
+function includeExtent(result, left, right, top, bottom) {
+  if (result === undefined) return { left, right, top, bottom };
+  result.left = Math.min(result.left, left);
+  result.right = Math.max(result.right, right);
+  result.top = Math.min(result.top, top);
+  result.bottom = Math.max(result.bottom, bottom);
+  return result;
+}
+
+function unionBounds(bounds) {
+  let result;
+  for (const item of bounds) {
+    if (item !== undefined) {
+      result = includeExtent(
+        result, item.left, item.right, item.top, item.bottom
+      );
+    }
+  }
+  return result;
+}
+
 function cubicValue(start, control1, control2, end, t) {
   const remaining = 1 - t;
-  return remaining ** 3 * start +
-    3 * remaining ** 2 * t * control1 +
-    3 * remaining * t ** 2 * control2 +
-    t ** 3 * end;
+  if (Math.max(
+    Math.abs(start),
+    Math.abs(control1),
+    Math.abs(control2),
+    Math.abs(end)
+  ) <= Number.MAX_VALUE / 4) {
+    return remaining ** 3 * start +
+      3 * remaining ** 2 * t * control1 +
+      3 * remaining * t ** 2 * control2 +
+      t ** 3 * end;
+  }
+  const left = interpolateNumber(start, control1, t);
+  const middle = interpolateNumber(control1, control2, t);
+  const right = interpolateNumber(control2, end, t);
+  return interpolateNumber(
+    interpolateNumber(left, middle, t),
+    interpolateNumber(middle, right, t),
+    t
+  );
 }
 
 function cubicExtrema(start, control1, control2, end) {
-  const quadratic = 3 * (-start + 3 * control1 - 3 * control2 + end);
-  const linear = 2 * (3 * start - 6 * control1 + 3 * control2);
-  const constant = 3 * (control1 - start);
-  const epsilon = Number.EPSILON * 64 * Math.max(
-    1,
+  let scale = Math.max(
+    Math.abs(start),
+    Math.abs(control1),
+    Math.abs(control2),
+    Math.abs(end)
+  );
+  const normalizeCoordinates = scale > Number.MAX_VALUE / 24 ||
+    (scale > 0 && scale < EPSILON);
+  if (normalizeCoordinates) {
+    start /= scale;
+    control1 /= scale;
+    control2 /= scale;
+    end /= scale;
+  }
+  let quadratic = 3 * (-start + 3 * control1 - 3 * control2 + end);
+  let linear = 2 * (3 * start - 6 * control1 + 3 * control2);
+  let constant = 3 * (control1 - start);
+  scale = Math.max(
     Math.abs(quadratic),
     Math.abs(linear),
     Math.abs(constant)
   );
+  let epsilon = EPSILON * Math.max(normalizeCoordinates ? 0 : 1, scale);
+  if (scale > Math.sqrt(Number.MAX_VALUE) / 2) {
+    quadratic /= scale;
+    linear /= scale;
+    constant /= scale;
+    epsilon = EPSILON;
+  }
   if (Math.abs(quadratic) <= epsilon) {
     if (Math.abs(linear) <= epsilon) return [];
     const root = -constant / linear;
@@ -43,14 +108,16 @@ function cubicExtrema(start, control1, control2, end) {
   ].filter(value => value > 0 && value < 1);
 }
 
-function pathPoints(commands) {
-  const points = [];
+export function resolvePathCommandBounds(commands) {
+  let bounds;
   let current;
   for (const command of commands) {
     if (command.op === "M" || command.op === "L") {
       if ([command.x, command.y].every(Number.isFinite)) {
         current = { x: command.x, y: command.y };
-        points.push(current);
+        bounds = includeExtent(
+          bounds, current.x, current.x, current.y, current.y
+        );
       }
       continue;
     }
@@ -64,25 +131,106 @@ function pathPoints(commands) {
       ...cubicExtrema(current.y, command.y1, command.y2, command.y)
     ]);
     for (const t of roots) {
-      points.push({
-        x: cubicValue(current.x, command.x1, command.x2, command.x, t),
-        y: cubicValue(current.y, command.y1, command.y2, command.y, t)
-      });
+      const x = cubicValue(current.x, command.x1, command.x2, command.x, t);
+      const y = cubicValue(current.y, command.y1, command.y2, command.y, t);
+      bounds = includeExtent(
+        bounds,
+        x,
+        x,
+        y,
+        y
+      );
     }
     current = { x: command.x, y: command.y };
   }
-  return points;
+  return bounds;
 }
 
-export function resolvePathCommandBounds(commands) {
-  const points = pathPoints(commands);
-  if (points.length === 0) return undefined;
-  return {
-    left: Math.min(...points.map(point => point.x)),
-    right: Math.max(...points.map(point => point.x)),
-    top: Math.min(...points.map(point => point.y)),
-    bottom: Math.max(...points.map(point => point.y))
-  };
+function endpointDirection(start, command, end, reverse = false) {
+  const endpoint = reverse ? end : start;
+  const candidates = command.op === "C"
+    ? reverse
+      ? [{ x: command.x2, y: command.y2 },
+          { x: command.x1, y: command.y1 }, start]
+      : [{ x: command.x1, y: command.y1 },
+          { x: command.x2, y: command.y2 }, end]
+    : [reverse ? start : end];
+  const sign = reverse ? -1 : 1;
+  for (const point of candidates) {
+    let x = (point.x - endpoint.x) * sign;
+    let y = (point.y - endpoint.y) * sign;
+    let length = Math.hypot(x, y);
+    if (length === Infinity) {
+      const scale = Math.max(
+        Math.abs(point.x), Math.abs(point.y),
+        Math.abs(endpoint.x), Math.abs(endpoint.y)
+      );
+      x = (point.x / scale - endpoint.x / scale) * sign;
+      y = (point.y / scale - endpoint.y / scale) * sign;
+      length = Math.hypot(x, y);
+    }
+    if (length !== 0) return { x: x / length, y: y / length };
+  }
+  return undefined;
+}
+
+function includeMiter(bounds, point, incoming, outgoing, strokeExtent) {
+  if (incoming === undefined || outgoing === undefined) return;
+  const cross = incoming.x * outgoing.y - incoming.y * outgoing.x;
+  if (Math.abs(cross) <= EPSILON) return;
+  const normalX = -incoming.y - outgoing.y;
+  const normalY = incoming.x + outgoing.x;
+  const normalLength = Math.hypot(normalX, normalY);
+  const ratio = 2 / normalLength;
+  if (ratio > 10 * (1 + EPSILON)) return;
+  const distance = strokeExtent * ratio * (cross > 0 ? -1 : 1) / normalLength;
+  includeExtent(
+    bounds,
+    point.x + normalX * distance,
+    point.x + normalX * distance,
+    point.y + normalY * distance,
+    point.y + normalY * distance
+  );
+}
+
+function pathStrokeBounds(commands, bounds, strokeExtent) {
+  const expanded = box(
+    bounds.left, bounds.right, bounds.top, bounds.bottom, strokeExtent
+  );
+  if (!(strokeExtent > 0)) return expanded;
+  const start = { x: commands[0].x, y: commands[0].y };
+  let current = start;
+  let firstDirection;
+  let previousDirection;
+  let segmentCount = 0;
+  for (const command of commands.slice(1)) {
+    const end = command.op === "Z"
+      ? start
+      : { x: command.x, y: command.y };
+    const outgoing = endpointDirection(current, command, end);
+    const incoming = endpointDirection(current, command, end, true);
+    if (outgoing !== undefined || incoming !== undefined) {
+      if (segmentCount > 0) {
+        includeMiter(expanded, current, previousDirection, outgoing, strokeExtent);
+      } else {
+        firstDirection = outgoing;
+      }
+      previousDirection = incoming;
+      segmentCount += 1;
+    }
+    current = end;
+    if (command.op === "Z") break;
+  }
+  if (commands.at(-1)?.op === "Z" && segmentCount > 1) {
+    includeMiter(
+      expanded,
+      start,
+      previousDirection,
+      firstDirection,
+      strokeExtent
+    );
+  }
+  return expanded;
 }
 
 function primitiveBounds(type, properties = {}) {
@@ -92,32 +240,34 @@ function primitiveBounds(type, properties = {}) {
       return undefined;
     }
     const radius = properties.radius + strokeExtent;
-    return {
-      left: properties.x - radius,
-      right: properties.x + radius,
-      top: properties.y - radius,
-      bottom: properties.y + radius
-    };
+    return box(
+      properties.x - radius,
+      properties.x + radius,
+      properties.y - radius,
+      properties.y + radius
+    );
   }
   if (type === "rect") {
     if (![properties.x, properties.y, properties.width, properties.height]
       .every(Number.isFinite)) return undefined;
-    return {
-      left: properties.x - strokeExtent,
-      right: properties.x + properties.width + strokeExtent,
-      top: properties.y - strokeExtent,
-      bottom: properties.y + properties.height + strokeExtent
-    };
+    return box(
+      properties.x,
+      properties.x + properties.width,
+      properties.y,
+      properties.y + properties.height,
+      strokeExtent
+    );
   }
   if (type === "line") {
     if (![properties.x1, properties.y1, properties.x2, properties.y2]
       .every(Number.isFinite)) return undefined;
-    return {
-      left: Math.min(properties.x1, properties.x2) - strokeExtent,
-      right: Math.max(properties.x1, properties.x2) + strokeExtent,
-      top: Math.min(properties.y1, properties.y2) - strokeExtent,
-      bottom: Math.max(properties.y1, properties.y2) + strokeExtent
-    };
+    return box(
+      Math.min(properties.x1, properties.x2),
+      Math.max(properties.x1, properties.x2),
+      Math.min(properties.y1, properties.y2),
+      Math.max(properties.y1, properties.y2),
+      strokeExtent
+    );
   }
   if (type === "text") {
     if (
@@ -133,51 +283,92 @@ function primitiveBounds(type, properties = {}) {
     if (!Array.isArray(commands)) return undefined;
     const bounds = resolvePathCommandBounds(commands);
     if (bounds === undefined) return undefined;
-    return {
-      left: bounds.left - strokeExtent,
-      right: bounds.right + strokeExtent,
-      top: bounds.top - strokeExtent,
-      bottom: bounds.bottom + strokeExtent
-    };
+    return pathStrokeBounds(commands, bounds, strokeExtent);
   }
   return undefined;
 }
 
-function objectBounds(graphicSpec, id, object, ancestors) {
-  if (ancestors.includes(id)) {
+function translateBounds(bounds, x, y) {
+  if (bounds === undefined) return undefined;
+  return box(
+    bounds.left + x,
+    bounds.right + x,
+    bounds.top + y,
+    bounds.bottom + y
+  );
+}
+
+function canvasOffset(object, property) {
+  const value = object.type === "canvas" ? object.properties?.[property] : 0;
+  return Number.isFinite(value) ? value : 0;
+}
+
+function ancestorOffset(graphicSpec, target) {
+  const offset = [0, 0];
+  const visited = new Set();
+  let current = target;
+  while (true) {
+    if (visited.has(current)) {
+      throw new Error(`Graphic attachment cycle includes "${current}".`);
+    }
+    visited.add(current);
+    const parent = findGraphicParent(graphicSpec, current);
+    if (parent === undefined) return offset;
+    offset[0] += canvasOffset(parent.object, "x");
+    offset[1] += canvasOffset(parent.object, "y");
+    current = parent.id;
+  }
+}
+
+function objectBounds(graphicSpec, id, object, ancestors, x, y) {
+  if (ancestors.has(id)) {
     throw new Error(`Graphic attachment cycle includes "${id}".`);
   }
-  const own = object.items === undefined
-    ? primitiveBounds(object.type, object.properties)
-    : unionBounds(object.items.flatMap(item => {
-        const bounds = primitiveBounds(item.type ?? object.type, item.properties);
-        return bounds === undefined ? [] : [bounds];
-      }));
-  const descendants = (object.children ?? []).flatMap(childId => {
+  ancestors.add(id);
+  let result = object.items === undefined
+    ? translateBounds(primitiveBounds(object.type, object.properties), x, y)
+    : unionBounds(object.items.map(item => translateBounds(
+        primitiveBounds(item.type ?? object.type, item.properties),
+        x,
+        y
+      )));
+  const childX = x + canvasOffset(object, "x");
+  const childY = y + canvasOffset(object, "y");
+  for (const childId of object.children ?? []) {
     const child = findGraphic(graphicSpec, childId);
     if (child?.kind !== "object") {
       throw new Error(`Unknown attached graphic "${childId}".`);
     }
-    const bounds = objectBounds(graphicSpec, childId, child.object, [...ancestors, id]);
-    return bounds === undefined ? [] : [bounds];
-  });
-  return unionBounds([...(own === undefined ? [] : [own]), ...descendants]);
+    const bounds = objectBounds(
+      graphicSpec, childId, child.object, ancestors, childX, childY
+    );
+    if (bounds !== undefined) {
+      result = includeExtent(
+        result, bounds.left, bounds.right, bounds.top, bounds.bottom
+      );
+    }
+  }
+  ancestors.delete(id);
+  return result;
 }
 
 export function resolveConcreteGraphicBounds(graphicSpec, target) {
   const found = requireGraphic(graphicSpec, target);
-  if (found.kind === "item") {
-    return primitiveBounds(found.object.type ?? found.owner.type, found.object.properties);
-  }
-  return objectBounds(graphicSpec, found.id, found.object, []);
+  const [x, y] = ancestorOffset(graphicSpec, target);
+  return requireFiniteBounds(found.kind === "item"
+    ? translateBounds(
+      primitiveBounds(found.object.type ?? found.owner.type, found.object.properties),
+      x,
+      y
+    )
+    : objectBounds(graphicSpec, found.id, found.object, new Set(), x, y));
 }
 
 export function unionConcreteGraphicBounds(graphicSpec, targets) {
   if (!Array.isArray(targets)) {
     throw new TypeError("Graphic bounds targets must be an array.");
   }
-  return unionBounds(targets.flatMap(target => {
-    const bounds = resolveConcreteGraphicBounds(graphicSpec, target);
-    return bounds === undefined ? [] : [bounds];
-  }));
+  return unionBounds(targets.map(target =>
+    resolveConcreteGraphicBounds(graphicSpec, target)
+  ));
 }

package/src/grammar/seriesLayout.js

@@ -1,5 +1,10 @@
 import { cloneAndFreeze } from "../core/immutable.js";
 import { COLOR_LAYOUTS } from "../core/vocabulary.js";
+import {
+  normalizedFiniteSum,
+  restoreFiniteScale,
+  requireFiniteResult
+} from "./numeric.js";
 
 export const DEFAULT_SERIES_BASELINE = 0;
 
@@ -16,6 +21,15 @@ function validateValues(values) {
   }
 }
 
+function requireResolvedSegment(start, end, value, layout) {
+  requireFiniteResult(end, `Series ${layout} end`);
+  if (value > 0 ? end <= start : end >= start) {
+    throw new RangeError(
+      `Series ${layout} value cannot resolve a distinct finite segment.`
+    );
+  }
+}
+
 export function layoutSeriesPartition(
   values,
   layout,
@@ -35,18 +49,43 @@ export function layoutSeriesPartition(
     ));
   }
 
-  if (["stack", "fill", "center"].includes(layout)) {
+  if (layout === "stack" || layout === "fill" || layout === "center") {
     if (values.some(value => value < 0)) {
       throw new RangeError(`${layout} layout requires non-negative values.`);
     }
     const total = values.reduce((sum, value) => sum + value, 0);
     if (layout === "fill" && total === 0) return cloneAndFreeze([]);
-    let offset = layout === "center" ? -total / 2 : 0;
+    const normalized = Number.isFinite(total)
+      ? undefined
+      : normalizedFiniteSum(values, `Series ${layout} values`);
+    if (layout === "stack" && normalized) {
+      throw new RangeError("Series stack total is outside the finite numeric range.");
+    }
+    let offset = 0;
+    if (layout === "center") {
+      offset = -(normalized
+        ? restoreFiniteScale(
+          normalized.total / 2,
+          normalized.scale,
+          "Series center half-total"
+        )
+        : total / 2);
+    }
+    let positiveIndex = 0;
+    const positiveCount = values.filter(value => value > 0).length;
     return cloneAndFreeze(values.flatMap((value, index) => {
       if (value === 0) return [];
-      const resolvedValue = layout === "fill" ? value / total : value;
+      positiveIndex += 1;
+      const resolvedValue = layout === "fill"
+        ? normalized
+          ? (value / normalized.scale) / normalized.total
+          : value / total
+        : value;
       const start = offset;
-      const end = start + resolvedValue;
+      const end = layout === "fill" && positiveIndex === positiveCount
+        ? 1
+        : start + resolvedValue;
+      requireResolvedSegment(start, end, value, layout);
       offset = end;
       return [{ index, value, start, end }];
     }));
@@ -58,6 +97,7 @@ export function layoutSeriesPartition(
     if (value === 0) return [];
     const start = value > 0 ? positive : negative;
     const end = start + value;
+    requireResolvedSegment(start, end, value, layout);
     if (value > 0) positive = end;
     else negative = end;
     return [{ index, value, start, end }];
@@ -78,18 +118,10 @@ export function resolveSeriesLayoutDomainValues(partitions, layout) {
       ...partition
     ]);
   }
-  if (layout === "center") {
-    return partitions.flatMap(partition => {
-      const segments = layoutSeriesPartition(partition, layout);
-      return segments.length === 0
-        ? [DEFAULT_SERIES_BASELINE]
-        : segments.flatMap(segment => [segment.start, segment.end]);
-    });
-  }
-  return partitions.flatMap(partition =>
-    layoutSeriesPartition(partition, layout).flatMap(segment => [
-      segment.start,
-      segment.end
-    ])
-  );
+  return partitions.flatMap(partition => {
+    const segments = layoutSeriesPartition(partition, layout);
+    return layout === "center" && segments.length === 0
+      ? [DEFAULT_SERIES_BASELINE]
+      : segments.flatMap(segment => [segment.start, segment.end]);
+  });
 }