ggaction 0.0.9 → 0.0.11

package/src/grammar/ticks.js

@@ -1,23 +1,77 @@
 import { cloneAndFreeze } from "../core/immutable.js";
+import {
+  MAX_GENERATED_ITEMS,
+  validateGeneratedItemLimit
+} from "../core/validation.js";
+import {
+  alignNumericStep,
+  cleanNumericValue,
+  niceNumericStep,
+  normalizeNumericRange
+} from "./numeric.js";
+import { utcTimestamp, validTimestamp } from "./timeUnit.js";
 
-const LINEAR_FACTORS = Object.freeze([1, 2, 3, 5]);
+function ticksForStep(start, end, step, low, high, scale) {
+  const length = Math.floor((end - start) / step + 1e-10) + 1;
+  if (!Number.isFinite(length) || length <= 0) return undefined;
+  const size = Math.min(length, MAX_GENERATED_ITEMS);
+  const values = [];
+  for (let index = 0; index < size; index += 1) {
+    const tick = length === size || size === 1
+      ? index
+      : Math.round(index * (length - 1) / (size - 1));
+    const raw = start + tick * step;
+    const value = scale === undefined
+      ? Number(raw.toPrecision(12))
+      : cleanNumericValue(raw * scale, step * scale);
+    if (
+      !Number.isFinite(value) || value < low || value > high ||
+      (values.length > 0 && value <= values.at(-1))
+    ) {
+      if (scale === undefined) return undefined;
+    } else {
+      values.push(value);
+    }
+  }
+  return values;
+}
 
 export function niceTicks(domain, count) {
   if (!Number.isInteger(count) || count <= 0) throw new RangeError("Tick count must be a positive integer.");
+  const effectiveCount = Math.min(count, MAX_GENERATED_ITEMS);
   const low = Math.min(...domain);
   const high = Math.max(...domain);
   if (low === high) return cloneAndFreeze([low]);
-  const rough = (high - low) / count;
-  const power = 10 ** Math.floor(Math.log10(rough));
-  const error = rough / power;
-  const factor = LINEAR_FACTORS.find(candidate => candidate >= error) ?? 10;
-  const step = factor * power;
-  const tolerance = step * 1e-10;
-  const start = Math.ceil((low - tolerance) / step) * step;
-  const end = Math.floor((high + tolerance) / step) * step;
-  const values = [];
-  for (let value = start; value <= end + step * 1e-10; value += step) values.push(+value.toPrecision(12));
-  return cloneAndFreeze(values);
+  const directSpan = high - low;
+  if (Number.isFinite(directSpan) && directSpan > 0) {
+    const directStep = niceNumericStep(directSpan, effectiveCount);
+    const tolerance = directStep * 1e-10;
+    const directStart = Math.ceil((low - tolerance) / directStep) * directStep;
+    const directEnd = Math.floor((high + tolerance) / directStep) * directStep;
+    const direct = ticksForStep(
+      directStart,
+      directEnd,
+      directStep,
+      low,
+      high
+    );
+    if (direct !== undefined && direct.length <= MAX_GENERATED_ITEMS) {
+      return cloneAndFreeze(direct);
+    }
+  }
+  const normalized = normalizeNumericRange(low, high);
+  const normalizedStep = niceNumericStep(normalized.span, effectiveCount);
+  const start = alignNumericStep(normalized.start, normalizedStep, "ceil");
+  const end = alignNumericStep(normalized.end, normalizedStep, "floor");
+  const values = ticksForStep(
+    start,
+    end,
+    normalizedStep,
+    low,
+    high,
+    normalized.scale
+  );
+  return cloneAndFreeze(values?.length > 0 ? values : [low, high]);
 }
 
 const SECOND = 1000;
@@ -39,19 +93,31 @@ function validateTimeDomain(domain) {
   if (
     !Array.isArray(domain) ||
     domain.length !== 2 ||
-    !domain.every(Number.isFinite)
+    !domain.every(validTimestamp)
   ) {
-    throw new TypeError("Time tick domain must contain two finite timestamps.");
+    throw new TypeError(
+      "Time tick domain must contain two finite timestamps representing valid dates."
+    );
   }
 
   return [Math.min(...domain), Math.max(...domain)];
 }
 
 function selectTimeInterval(span, count) {
-  return TIME_INTERVALS.reduce((best, candidate) => {
+  let interval = TIME_INTERVALS[0];
+  let bestError = Infinity;
+  for (const candidate of TIME_INTERVALS) {
     const error = Math.abs(span / candidate.duration - count);
-    return error < best.error ? { ...candidate, error } : best;
-  }, { ...TIME_INTERVALS[0], error: Infinity });
+    if (error < bestError) {
+      interval = candidate;
+      bestError = error;
+    }
+  }
+  if (span / interval.duration + 1 > Math.max(count * 10, 100)) {
+    const step = niceNumericStep(span / YEAR, count);
+    return { unit: "year", step, duration: step * YEAR };
+  }
+  return interval;
 }
 
 function floorCalendar(timestamp, { unit, step }) {
@@ -59,13 +125,13 @@ function floorCalendar(timestamp, { unit, step }) {
 
   if (unit === "year") {
     const year = Math.floor(date.getUTCFullYear() / step) * step;
-    return Date.UTC(year, 0, 1);
+    return utcTimestamp(year);
   }
 
   if (unit === "month") {
     const month = date.getUTCFullYear() * 12 + date.getUTCMonth();
     const aligned = Math.floor(month / step) * step;
-    return Date.UTC(Math.floor(aligned / 12), aligned % 12, 1);
+    return utcTimestamp(Math.floor(aligned / 12), aligned % 12);
   }
 
   const duration = unit === "day"
@@ -79,43 +145,44 @@ function floorCalendar(timestamp, { unit, step }) {
   return Math.floor(timestamp / duration) * duration;
 }
 
-function addCalendar(timestamp, { unit, step }) {
-  const date = new Date(timestamp);
-
-  if (unit === "year") {
-    return Date.UTC(date.getUTCFullYear() + step, 0, 1);
+function addCalendar(timestamp, interval) {
+  if (interval.unit === "year" || interval.unit === "month") {
+    const date = new Date(timestamp);
+    return utcTimestamp(
+      date.getUTCFullYear() + (interval.unit === "year" ? interval.step : 0),
+      date.getUTCMonth() + (interval.unit === "month" ? interval.step : 0)
+    );
   }
-
-  if (unit === "month") {
-    return Date.UTC(date.getUTCFullYear(), date.getUTCMonth() + step, 1);
-  }
-
-  const duration = unit === "day"
-    ? step * DAY
-    : unit === "hour"
-      ? step * HOUR
-      : unit === "minute"
-        ? step * MINUTE
-        : step * SECOND;
-
-  return timestamp + duration;
+  return timestamp + interval.duration;
 }
 
 export function timeTicks(domain, count) {
   if (!Number.isInteger(count) || count <= 0) {
     throw new RangeError("Time tick count must be a positive integer.");
   }
+  validateGeneratedItemLimit(count, "Time tick count");
 
   const [low, high] = validateTimeDomain(domain);
   if (low === high) return cloneAndFreeze([low]);
   const interval = selectTimeInterval(high - low, count);
   let value = floorCalendar(low, interval);
+  if (!validTimestamp(value) && interval.unit === "year") {
+    const year = new Date(low).getUTCFullYear();
+    value = utcTimestamp(Math.ceil(year / interval.step) * interval.step);
+  }
   if (value < low) value = addCalendar(value, interval);
   const values = [];
 
   while (value <= high) {
+    if (values.length === MAX_GENERATED_ITEMS) {
+      throw new RangeError(
+        `Time tick range must generate at most ${MAX_GENERATED_ITEMS} ticks.`
+      );
+    }
     values.push(value);
-    value = addCalendar(value, interval);
+    const next = addCalendar(value, interval);
+    if (!validTimestamp(next) || next <= value) break;
+    value = next;
   }
 
   return cloneAndFreeze(values.length === 0 ? [low, high] : values);
@@ -125,9 +192,18 @@ function pad(value) {
   return String(value).padStart(2, "0");
 }
 
+function formatYear(value) {
+  if (value >= 0 && value <= 9999) return String(value).padStart(4, "0");
+  const sign = value < 0 ? "-" : "+";
+  return `${sign}${String(Math.abs(value)).padStart(6, "0")}`;
+}
+
 function formatTimePrecision(value, precision) {
   const date = new Date(value);
-  const year = String(date.getUTCFullYear()).padStart(4, "0");
+  if (!Number.isFinite(date.getTime())) {
+    throw new TypeError("Time tick value must represent a valid date.");
+  }
+  const year = formatYear(date.getUTCFullYear());
   const month = pad(date.getUTCMonth() + 1);
   const day = pad(date.getUTCDate());
   const hour = pad(date.getUTCHours());
@@ -157,22 +233,14 @@ function timePrecision(domain) {
 }
 
 export function formatTimeTick(value, domain) {
-  if (!Number.isFinite(value)) {
-    throw new TypeError("Time tick value must be a finite timestamp.");
+  if (!validTimestamp(value)) {
+    throw new TypeError(
+      "Time tick value must be a finite timestamp representing a valid date."
+    );
   }
   return formatTimePrecision(value, timePrecision(domain));
 }
 
-function distinguishesTicks(values, labels) {
-  const timestamps = new Map();
-  for (let index = 0; index < values.length; index += 1) {
-    const previous = timestamps.get(labels[index]);
-    if (previous !== undefined && previous !== values[index]) return false;
-    timestamps.set(labels[index], values[index]);
-  }
-  return true;
-}
-
 export function formatTimeTicks(values, domain) {
   if (!Array.isArray(values) || !values.every(Number.isFinite)) {
     throw new TypeError("Time tick values must be finite timestamps.");
@@ -180,7 +248,9 @@ export function formatTimeTicks(values, domain) {
   const initial = timePrecision(domain);
   for (let precision = initial; precision <= 6; precision += 1) {
     const labels = values.map(value => formatTimePrecision(value, precision));
-    if (distinguishesTicks(values, labels)) return cloneAndFreeze(labels);
+    if (new Set(labels).size === new Set(values).size) {
+      return cloneAndFreeze(labels);
+    }
   }
   return cloneAndFreeze(values.map(value => String(value)));
 }

package/src/grammar/timeUnit.js

@@ -1,6 +1,23 @@
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
 import { normalizeTemporalValue } from "./scales/fields.js";
 
+export function utcTimestamp(
+  year,
+  month = 0,
+  day = 1,
+  hour = 0,
+  minute = 0
+) {
+  const date = new Date(0);
+  date.setUTCFullYear(year, month, day);
+  date.setUTCHours(hour, minute, 0, 0);
+  return date.getTime();
+}
+
+export function validTimestamp(value) {
+  return Number.isFinite(value) && Number.isFinite(new Date(value).getTime());
+}
+
 export const TIME_UNITS = cloneAndFreeze([
   "year",
   "quarter",
@@ -52,13 +69,6 @@ export function normalizeTimeUnitTransform({ field, unit, as } = {}) {
   return cloneAndFreeze(transform);
 }
 
-function utcTimestamp(year, month = 0, day = 1, hour = 0, minute = 0) {
-  const date = new Date(0);
-  date.setUTCFullYear(year, month, day);
-  date.setUTCHours(hour, minute, 0, 0);
-  return date.getTime();
-}
-
 export function floorUtcTimeUnit(timestamp, unit) {
   if (!Number.isFinite(timestamp)) {
     throw new TypeError("Time-unit timestamp must be finite.");
@@ -67,7 +77,7 @@ export function floorUtcTimeUnit(timestamp, unit) {
     throw new Error(`Unsupported time unit "${unit}".`);
   }
   const date = new Date(timestamp);
-  if (!Number.isFinite(date.getTime())) {
+  if (!validTimestamp(timestamp)) {
     throw new TypeError("Time-unit timestamp must represent a valid date.");
   }
   const year = date.getUTCFullYear();

package/src/grammar/transforms.js

@@ -32,7 +32,10 @@ function facetHorizonTransform(transform, { scales = {} } = {}) {
     (scales.y ?? "shared") !== "shared" ||
     !Array.isArray(transform.resolved?.extents)
   ) return transform;
-  const extent = Math.max(...transform.resolved.extents.map(item => item.extent));
+  let extent = -Infinity;
+  for (const item of transform.resolved.extents) {
+    extent = Math.max(extent, item.extent);
+  }
   if (!(extent > 0)) return transform;
   return {
     ...requestedHorizonTransform(transform),

package/src/grammar/window.js

@@ -1,18 +1,23 @@
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
+import {
+  stableFiniteMean,
+  stableFinitePrefixSums,
+  stableFiniteSum
+} from "./numeric.js";
 
-const TRANSFORM_KEYS = Object.freeze([
+const TRANSFORM_KEYS = [
   "type", "partitionBy", "sortBy", "operations"
-]);
-const SORT_KEYS = Object.freeze(["field", "order"]);
-const ORDER_VALUES = Object.freeze(["ascending", "descending"]);
-const OPERATION_VALUES = Object.freeze([
+];
+const SORT_KEYS = ["field", "order"];
+const ORDER_VALUES = ["ascending", "descending"];
+const OPERATION_VALUES = [
   "rowNumber", "rank", "denseRank", "cumulativeSum", "lag", "lead",
   "movingMean", "movingSum"
-]);
-const POSITION_OPERATIONS = new Set(["rowNumber", "rank", "denseRank"]);
-const OFFSET_OPERATIONS = new Set(["lag", "lead"]);
-const MOVING_OPERATIONS = new Set(["movingMean", "movingSum"]);
-const FRAME_KEYS = Object.freeze(["preceding", "following"]);
+];
+const POSITION_OPERATIONS = new Set(OPERATION_VALUES.slice(0, 3));
+const OFFSET_OPERATIONS = new Set(OPERATION_VALUES.slice(4, 6));
+const MOVING_OPERATIONS = new Set(OPERATION_VALUES.slice(-2));
+const FRAME_KEYS = ["preceding", "following"];
 
 function requireField(value, label) {
   if (typeof value !== "string" || value.length === 0) {
@@ -77,15 +82,12 @@ function validateFrame(frame, operation) {
     throw new TypeError(`Window ${operation} frame must be a plain object.`);
   }
   rejectUnknownKeys(frame, FRAME_KEYS, `window ${operation} frame`);
-  if (!Number.isInteger(frame.preceding) || frame.preceding < 0) {
-    throw new RangeError(
-      `Window ${operation} frame preceding must be a non-negative integer.`
-    );
-  }
-  if (!Number.isInteger(frame.following) || frame.following < 0) {
-    throw new RangeError(
-      `Window ${operation} frame following must be a non-negative integer.`
-    );
+  for (const field of FRAME_KEYS) {
+    if (!Number.isInteger(frame[field]) || frame[field] < 0) {
+      throw new RangeError(
+        `Window ${operation} frame ${field} must be a non-negative integer.`
+      );
+    }
   }
 }
 
@@ -264,12 +266,6 @@ function validateSourceFields(rows, transform) {
 }
 
 function validatePartitionSortValues(partition, transform) {
-  for (const field of transform.partitionBy) {
-    partition.forEach(entry => scalarKey(
-      entry.row[field],
-      `Window partition field "${field}"`
-    ));
-  }
   for (const sort of transform.sortBy) {
     const types = new Set(partition.flatMap(({ row }) => {
       const value = row[sort.field];
@@ -301,12 +297,45 @@ function partitionRows(entries, partitionBy) {
         entry.row[field],
         `Window partition field "${field}"`
       )).join("\0");
-    if (!partitions.has(key)) partitions.set(key, []);
-    partitions.get(key).push(entry);
+    let partition = partitions.get(key);
+    if (partition === undefined) {
+      partition = [];
+      partitions.set(key, partition);
+    }
+    partition.push(entry);
   }
   return [...partitions.values()];
 }
 
+function operationValues(
+  partition,
+  operation,
+  first = 0,
+  last = partition.length - 1
+) {
+  const values = [];
+  for (let index = first; index <= last; index += 1) {
+    const value = partition[index].row[operation.field];
+    if (!Number.isFinite(value)) {
+      throw new TypeError(
+        `Window ${operation.op} field "${operation.field}" must contain finite numbers.`
+      );
+    }
+    values.push(value);
+  }
+  return values;
+}
+
+function stableWindowOutput(operation, calculate) {
+  const label = `Window ${operation.op} output "${operation.as}"`;
+  try {
+    return calculate(label);
+  } catch (error) {
+    if (!(error instanceof RangeError)) throw error;
+    throw new RangeError(`${label} must be finite.`);
+  }
+}
+
 function applyOperation(partition, operation, sortBy) {
   if (operation.op === "rowNumber") {
     partition.forEach((entry, index) => {
@@ -330,44 +359,29 @@ function applyOperation(partition, operation, sortBy) {
     return;
   }
   if (operation.op === "cumulativeSum") {
-    let total = 0;
-    for (const entry of partition) {
-      const value = entry.row[operation.field];
-      if (!Number.isFinite(value)) {
-        throw new TypeError(
-          `Window cumulativeSum field "${operation.field}" must contain finite numbers.`
-        );
-      }
-      total += value;
-      entry.row[operation.as] = total;
-    }
+    const values = operationValues(partition, operation);
+    const totals = stableWindowOutput(operation, label =>
+      stableFinitePrefixSums(values, label)
+    );
+    partition.forEach((entry, index) => {
+      entry.row[operation.as] = totals[index];
+    });
     return;
   }
   if (MOVING_OPERATIONS.has(operation.op)) {
+    const calculate = operation.op === "movingMean"
+      ? stableFiniteMean
+      : stableFiniteSum;
     partition.forEach((entry, index) => {
       const first = Math.max(0, index - operation.frame.preceding);
       const last = Math.min(
         partition.length - 1,
         index + operation.frame.following
       );
-      let total = 0;
-      for (let peerIndex = first; peerIndex <= last; peerIndex += 1) {
-        const value = partition[peerIndex].row[operation.field];
-        if (!Number.isFinite(value)) {
-          throw new TypeError(
-            `Window ${operation.op} field "${operation.field}" must contain finite numbers.`
-          );
-        }
-        total += value;
-        if (!Number.isFinite(total)) {
-          throw new RangeError(
-            `Window ${operation.op} output "${operation.as}" must be finite.`
-          );
-        }
-      }
-      entry.row[operation.as] = operation.op === "movingMean"
-        ? total / (last - first + 1)
-        : total;
+      const values = operationValues(partition, operation, first, last);
+      entry.row[operation.as] = stableWindowOutput(operation, label =>
+        calculate(values, label)
+      );
     });
     return;
   }
@@ -400,6 +414,5 @@ export function deriveWindowRows(rows, transform) {
       applyOperation(partition, operation, transform.sortBy);
     }
   }
-  entries.sort((left, right) => left.index - right.index);
   return cloneAndFreeze(entries.map(entry => entry.row));
 }

package/src/index.js

@@ -1,3 +1,3 @@
+export { render } from "./renderers/canvas/index.js";
 export { chart } from "./ChartProgram.js";
 export { hconcat, vconcat } from "./composition.js";
-export { render } from "./renderers/canvas/index.js";

package/src/layout/canvas.js

@@ -1,7 +1,8 @@
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
 import {
   validateNonEmptyString,
-  validateNonNegativeFinite
+  validateNonNegativeFinite,
+  validatePositiveFinite
 } from "../core/validation.js";
 
 const MARGIN_KEYS = Object.freeze(["top", "right", "bottom", "left"]);
@@ -63,13 +64,8 @@ export function normalizeMargin(margin, base = DEFAULT_MARGIN) {
 }
 
 export function validateCanvasState({ width, height, background, margin }) {
-  if (!Number.isInteger(width) || width <= 0) {
-    throw new RangeError("Canvas width must be a positive integer.");
-  }
-
-  if (!Number.isInteger(height) || height <= 0) {
-    throw new RangeError("Canvas height must be a positive integer.");
-  }
+  validatePositiveFinite(width, "Canvas width");
+  validatePositiveFinite(height, "Canvas height");
 
   validateNonEmptyString(background, "Canvas background");
 

package/src/layout/composition.js

@@ -1,9 +1,9 @@
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
 
-const DIRECTIONS = Object.freeze(["horizontal", "vertical"]);
-const ALIGNMENTS = Object.freeze(["start", "center", "end"]);
-const SIZE_MODES = Object.freeze(["auto", "explicit"]);
-const PADDING_KEYS = Object.freeze(["top", "right", "bottom", "left"]);
+const DIRECTIONS = ["horizontal", "vertical"];
+const ALIGNMENTS = ["start", "center", "end"];
+const SIZE_MODES = ["auto", "explicit"];
+const PADDING_KEYS = ["top", "right", "bottom", "left"];
 
 export const DEFAULT_COMPOSITION_LAYOUT = cloneAndFreeze({
   gap: 16,
@@ -124,21 +124,16 @@ export function normalizeCompositionChildren(children) {
 function normalizeAutoCrossSize(children, horizontal) {
   const dimension = horizontal ? "height" : "width";
   const mode = `${dimension}Mode`;
-  const sharedSize = Math.max(...children.map(child => child[dimension]));
+  const sharedSize = children.reduce(
+    (maximum, child) => Math.max(maximum, child[dimension]),
+    -Infinity
+  );
   return children.map(child => cloneAndFreeze({
     ...child,
     [dimension]: child[mode] === "auto" ? sharedSize : child[dimension]
   }));
 }
 
-function placementSize(child) {
-  return {
-    id: child.id,
-    width: child.width,
-    height: child.height
-  };
-}
-
 function crossOffset(remaining, align) {
   if (align === "start") return 0;
   if (align === "end") return remaining;
@@ -162,30 +157,36 @@ export function resolveCompositionLayout({
   const contentWidth = horizontal
     ? sizedChildren.reduce((sum, child) => sum + child.width, 0) +
       resolvedGap * (sizedChildren.length - 1)
-    : Math.max(...sizedChildren.map(child => child.width));
+    : sizedChildren.reduce(
+        (maximum, child) => Math.max(maximum, child.width),
+        -Infinity
+      );
   const contentHeight = horizontal
-    ? Math.max(...sizedChildren.map(child => child.height))
+    ? sizedChildren.reduce(
+        (maximum, child) => Math.max(maximum, child.height),
+        -Infinity
+      )
     : sizedChildren.reduce((sum, child) => sum + child.height, 0) +
       resolvedGap * (sizedChildren.length - 1);
   let cursor = horizontal ? resolvedPadding.left : resolvedPadding.top;
   const placements = sizedChildren.map(child => {
-    const placement = horizontal
-      ? {
-          ...placementSize(child),
-          x: cursor,
-          y: resolvedPadding.top + crossOffset(
-            contentHeight - child.height,
-            resolvedAlign
-          )
-        }
-      : {
-          ...placementSize(child),
-          x: resolvedPadding.left + crossOffset(
+    const placement = {
+      id: child.id,
+      width: child.width,
+      height: child.height,
+      x: horizontal
+        ? cursor
+        : resolvedPadding.left + crossOffset(
             contentWidth - child.width,
             resolvedAlign
           ),
-          y: cursor
-        };
+      y: horizontal
+        ? resolvedPadding.top + crossOffset(
+            contentHeight - child.height,
+            resolvedAlign
+          )
+        : cursor
+    };
     cursor += (horizontal ? child.width : child.height) + resolvedGap;
     return placement;
   });
@@ -264,7 +265,11 @@ export function resolvePlacedPlotBounds({ placements, plots } = {}) {
     }
     plotById.set(plot.id, validatePlacedBounds(plot, `Placed plot "${plot.id}"`));
   }
-  const translated = placements.map((placement, index) => {
+  let left = Infinity;
+  let top = Infinity;
+  let right = -Infinity;
+  let bottom = -Infinity;
+  placements.forEach((placement, index) => {
     if (
       !isPlainObject(placement) ||
       typeof placement.id !== "string" ||
@@ -287,20 +292,14 @@ export function resolvePlacedPlotBounds({ placements, plots } = {}) {
       );
     }
     plotById.delete(placement.id);
-    return {
-      left: placement.x + plot.x,
-      top: placement.y + plot.y,
-      right: placement.x + plot.x + plot.width,
-      bottom: placement.y + plot.y + plot.height
-    };
+    left = Math.min(left, placement.x + plot.x);
+    top = Math.min(top, placement.y + plot.y);
+    right = Math.max(right, placement.x + plot.x + plot.width);
+    bottom = Math.max(bottom, placement.y + plot.y + plot.height);
   });
   if (plotById.size > 0) {
     throw new Error(`Unknown placed plot id "${plotById.keys().next().value}".`);
   }
-  const left = Math.min(...translated.map(bounds => bounds.left));
-  const top = Math.min(...translated.map(bounds => bounds.top));
-  const right = Math.max(...translated.map(bounds => bounds.right));
-  const bottom = Math.max(...translated.map(bounds => bounds.bottom));
   return cloneAndFreeze({
     x: left,
     y: top,