@inflexa-ai/harness 0.45.0 → 0.46.0

package/dist/report-render/figures/dendrogram.d.ts

@@ -16,11 +16,11 @@ import type { Cell } from "../chart.js";
 import type { RenderProblem } from "../types.js";
 import type { FigureTree } from "./index.js";
 /** One checked tree: the axis categories in leaf order, and the elbow of each edge in table order. */
-export interface CheckedTree {
+export type CheckedTree = {
     readonly order: readonly Cell[];
     readonly height: number;
     readonly elbows: readonly Elbow[];
-}
+};
 /**
  * The elbow of one edge, in tree coordinates: the place along the axis and the height of each of its three
  * points. It rises from the child to the height of the parent, then it runs across to the place of the parent.
@@ -33,4 +33,4 @@ export type Elbow = readonly [readonly [number, number], readonly [number, numbe
  * number, a node with two heights or two parents, no root or two roots, a cycle, a child over its parent, a
  * leaf that is no category, and a category that no leaf names.
  */
-export declare function checkTree(blockId: string, axis: "x" | "y", tree: FigureTree, categories: readonly Cell[]): Result<CheckedTree, RenderProblem>;
+export declare function checkTree(blockId: string, axis: "x" | "y", tree: FigureTree, categories: ReadonlyArray<Cell | undefined>): Result<CheckedTree, RenderProblem>;

package/dist/report-render/figures/dendrogram.js

@@ -54,19 +54,20 @@ export function checkTree(blockId, axis, tree, categories) {
         edges.push({ parent, child, height });
     }
     const roots = [...childrenOf.keys()].filter((node) => !parentOf.has(node));
-    if (roots.length === 0)
-        return fault(`holds a cycle through the node "${edges[0].parent}".`);
+    const root = roots[0];
+    if (root === undefined)
+        return fault(`holds a cycle through the node "${String(edges[0]?.parent)}".`);
     if (roots.length > 1)
-        return fault(`holds more than one root, for example "${roots[0]}" and "${roots[1]}". A tree holds one root.`);
+        return fault(`holds more than one root, for example "${String(roots[0])}" and "${String(roots[1])}". A tree holds one root.`);
     // Each child has one parent and the root has none, thus a walk from the root meets each node one time. A
     // node that the walk never meets sits on a cycle apart from the root.
     const preorder = [];
-    const stack = [roots[0]];
+    const stack = [root];
     for (let node = stack.pop(); node !== undefined; node = stack.pop()) {
         preorder.push(node);
         const children = childrenOf.get(node) ?? [];
-        for (let index = children.length - 1; index >= 0; index -= 1)
-            stack.push(children[index]);
+        for (const child of children.slice().reverse())
+            stack.push(child);
     }
     const met = new Set(preorder);
     const stray = edges.find((edge) => !met.has(edge.parent));
@@ -96,9 +97,8 @@ export function checkTree(blockId, axis, tree, categories) {
     const place = new Map(leaves.map((leaf, index) => [leaf, index]));
     // The reverse of the preorder meets each child before its parent, and the walk met each node, thus each
     // lookup below finds a place.
-    const placeOf = (node) => place.get(node);
-    for (let index = preorder.length - 1; index >= 0; index -= 1) {
-        const node = preorder[index];
+    const placeOf = (node) => place.get(node) ?? Number.NaN;
+    for (const node of preorder.slice().reverse()) {
         const children = childrenOf.get(node);
         if (children === undefined)
             continue;
@@ -119,7 +119,7 @@ export function checkTree(blockId, axis, tree, categories) {
             [placeOf(edge.parent), edge.height],
         ];
     });
-    return ok({ order, height: heightAt(roots[0]), elbows });
+    return ok({ order, height: heightAt(root), elbows });
 }
 /** The name of one node cell, or `undefined` for an empty cell. */
 function nodeName(cell) {

package/dist/report-render/figures/dense.js

@@ -8,11 +8,14 @@
  */
 import { err, ok } from "neverthrow";
 import { channelColumn, channelTransform } from "../../contracts/report-blocks.js";
+import { parseUnknownRecord } from "../../lib/unknown-containers.js";
 import { SIZED_SERIES_MEMBER } from "../chart-renderers.js";
 import { CHART_EXPORT_SIZES, CHART_INK } from "../design.js";
 import { formatNumberCell } from "../number-format.js";
 import { chartProblem, toNumber, transformColumn } from "./common.js";
 import { EXPORT_PLOT_FRAMES, PAGE_PLOT_FRAME } from "./label-room.js";
+/** The plot frames of each export size, keyed by the same kind that names the size. */
+const EXPORT_SIZE_KINDS = ["single", "double", "slide"];
 /**
  * The symbol sizes in pixels of a dense figure: a signal point, and a point that states no finding.
  *
@@ -47,8 +50,8 @@ export const BELOW_RESOLUTION_TOOLTIP = { formatter: "{b}<br/>{a}: p = 0" };
  */
 export function belowResolutionRows(rows, pColumn, others) {
     const found = [];
-    for (let index = 0; index < rows.length; index += 1) {
-        if (toNumber(rows[index][pColumn]) === 0 && others[index] !== null)
+    for (const [index, row] of rows.entries()) {
+        if (toNumber(row[pColumn]) === 0 && others[index] !== null)
             found.push(index);
     }
     return found;
@@ -117,8 +120,8 @@ export function pointNameSeries(names, placed) {
  */
 export function sizedSeries(names, build) {
     const widths = {};
-    for (const [kind, size] of Object.entries(CHART_EXPORT_SIZES)) {
-        widths[String(size.widthPx)] = build(EXPORT_PLOT_FRAMES[kind]);
+    for (const kind of EXPORT_SIZE_KINDS) {
+        widths[String(CHART_EXPORT_SIZES[kind].widthPx)] = build(EXPORT_PLOT_FRAMES[kind]);
     }
     const sized = { names, widths };
     return { page: build(PAGE_PLOT_FRAME), member: { [SIZED_SERIES_MEMBER]: sized } };
@@ -187,16 +190,20 @@ export function smallest(values) {
 /** The series of an option, as objects. */
 export function seriesOf(option) {
     const series = option.series;
-    return Array.isArray(series) ? series.filter((entry) => typeof entry === "object" && entry !== null) : [];
+    return Array.isArray(series)
+        ? series.flatMap((entry) => {
+            const record = parseUnknownRecord(entry);
+            return record === undefined ? [] : [record];
+        })
+        : [];
 }
 /** The axis of an option as one object. A composition of one grid gives one object for each axis. */
 export function axisOf(option, key) {
-    const axis = option[key];
-    return typeof axis === "object" && axis !== null && !Array.isArray(axis) ? axis : {};
+    return parseUnknownRecord(option[key]) ?? {};
 }
 /** The fields of one layer of points: the fill, the opacity, the symbol size, and the drawing order. */
 export function pointLayer(color, size, opacity, z) {
-    return { itemStyle: { color, opacity }, symbolSize: size, ...(z !== undefined ? { z } : {}) };
+    return { itemStyle: { color, opacity }, symbolSize: size, z };
 }
 /** The shown text of a count in a legend name: a whole number with a thousands separator. */
 export function countText(count) {

package/dist/report-render/figures/dotplot.js

@@ -14,9 +14,12 @@
  * The dots build through the composition machinery. The figure moves each dot onto the place of its category,
  * and the page builds no such move, thus the rows stay inline whatever their count.
  */
+import { textOf } from "../../lib/unknown-text.js";
 import { err, ok } from "neverthrow";
 import { channelColumn, channelOrder, channelTransform } from "../../contracts/report-blocks.js";
 import { declaredForColumn } from "../../contracts/report-reference.js";
+import { isUnknownArray } from "../../lib/unknown-array.js";
+import { parseUnknownRecord } from "../../lib/unknown-containers.js";
 import { CHART_BODY_PX, SEQUENTIAL_RAMP } from "../design.js";
 import { categoryAxis, categoryAxisTitle, chartProblem, colorScale, orderQuickCategories, sizeLegend, toNumber, transformedTitle, withFigureBody, } from "./common.js";
 /** The band at the right of the plot that holds the color scale and the size legend, in percent of the width. */
@@ -69,10 +72,13 @@ export function wrappedTerm(term) {
     if (lines.length <= DOTPLOT_TERM_LINES)
         return lines.join("\n");
     const kept = lines.slice(0, DOTPLOT_TERM_LINES);
-    const last = kept[DOTPLOT_TERM_LINES - 1].split(" ");
-    while (last.length > 1 && `${last.join(" ")}…`.length > DOTPLOT_WRAP_CHARACTERS)
-        last.pop();
-    kept[DOTPLOT_TERM_LINES - 1] = `${last.join(" ")}…`;
+    const last = kept[kept.length - 1];
+    if (last === undefined)
+        return lines.join("\n");
+    const words = last.split(" ");
+    while (words.length > 1 && `${words.join(" ")}…`.length > DOTPLOT_WRAP_CHARACTERS)
+        words.pop();
+    kept[kept.length - 1] = `${words.join(" ")}…`;
     return kept.join("\n");
 }
 /**
@@ -104,10 +110,11 @@ function formatSource(context, channel) {
 }
 /** The members of one item: the array form, or the value of the object form. */
 function itemValue(item) {
-    if (Array.isArray(item))
+    if (isUnknownArray(item))
         return item;
-    if (typeof item === "object" && item !== null && Array.isArray(item.value))
-        return item.value;
+    const carried = parseUnknownRecord(item)?.value;
+    if (isUnknownArray(carried))
+        return carried;
     return undefined;
 }
 /** One item with its y member set to the place of its category. */
@@ -116,7 +123,7 @@ function placedItem(item, place) {
     if (value === undefined)
         return item;
     const moved = [value[0], place, ...value.slice(2)];
-    return Array.isArray(item) ? moved : { ...item, value: moved };
+    return Array.isArray(item) ? moved : { ...parseUnknownRecord(item), value: moved };
 }
 function deriveDotplot(block, rows, context) {
     const encoding = block.encoding ?? {};
@@ -142,9 +149,9 @@ function deriveDotplot(block, rows, context) {
                     x,
                     // The figure orders the y categories itself, thus the composition reads the plain column.
                     y: yColumn,
-                    ...(size !== undefined ? { size } : {}),
-                    ...(color !== undefined ? { color } : {}),
-                    ...(label !== undefined ? { label } : {}),
+                    size,
+                    color,
+                    label,
                 },
             },
         ],
@@ -155,23 +162,26 @@ function deriveDotplot(block, rows, context) {
         return err(composed.error);
     const option = composed.value;
     const places = new Map(categories.value.map((category, place) => [String(category), place]));
-    const series = (Array.isArray(option.series) ? option.series : []).map((entry) => ({
-        ...entry,
-        data: (Array.isArray(entry.data) ? entry.data : []).flatMap((item) => {
-            const place = places.get(String(itemValue(item)?.[1]));
-            return place === undefined ? [] : [placedItem(item, place)];
-        }),
-    }));
+    const series = (isUnknownArray(option.series) ? option.series : []).map((entry) => {
+        const fields = parseUnknownRecord(entry) ?? {};
+        return {
+            ...fields,
+            data: (isUnknownArray(fields.data) ? fields.data : []).flatMap((item) => {
+                const place = places.get(textOf(itemValue(item)?.[1]));
+                return place === undefined ? [] : [placedItem(item, place)];
+            }),
+        };
+    });
     const wraps = categories.value.some((category) => String(category).length > DOTPLOT_WRAP_CHARACTERS);
     // The series place each dot by the index of its term, thus the axis can show the wrapped text of a term.
     const terms = wraps ? categories.value.map((category) => wrappedTerm(String(category))) : undefined;
     const yAxis = {
         ...categoryAxis("y", terms ?? categories.value, { title: categoryAxisTitle(context.labels, yColumn), topDown: true }),
-        ...(wraps ? { axisLabel: { lineHeight: DOTPLOT_LINE_PX } } : {}),
+        axisLabel: wraps ? { lineHeight: DOTPLOT_LINE_PX } : undefined,
     };
     const lines = terms === undefined ? 1 : highestOf(terms.map((term) => term.split("\n").length));
     const body = (categories.value.length * (lines * DOTPLOT_LINE_PX + DOTPLOT_ROW_GAP_PX)) / DOTPLOT_PLOT_SHARE;
-    const maps = Array.isArray(option.visualMap) ? option.visualMap : [];
+    const maps = isUnknownArray(option.visualMap) ? option.visualMap.map((entry) => parseUnknownRecord(entry) ?? {}) : [];
     const keys = [];
     const graphic = [];
     const colorMap = maps.find((entry) => entry.show !== false);
@@ -183,13 +193,14 @@ function deriveDotplot(block, rows, context) {
     }
     const sizeMaps = maps.filter((entry) => entry.show === false);
     keys.push(...sizeMaps);
-    if (size !== undefined && sizeMaps.length > 0) {
-        const range = { min: toNumber(sizeMaps[0].min) ?? 0, max: toNumber(sizeMaps[0].max) ?? 0 };
+    const sizeMap = sizeMaps[0];
+    if (size !== undefined && sizeMap !== undefined) {
+        const range = { min: toNumber(sizeMap.min) ?? 0, max: toNumber(sizeMap.max) ?? 0 };
         graphic.push(sizeLegend(range, scaleTitle(context.labels, size), formatSource(context, size)[0], DOTPLOT_SIZE_PLACE, formatSource(context, size)[1]));
     }
-    const composedX = typeof option.xAxis === "object" && option.xAxis !== null ? option.xAxis : {};
+    const composedX = parseUnknownRecord(option.xAxis) ?? {};
     const xAxis = composedX.type === "value"
-        ? { ...composedX, boundaryGap: [...DOTPLOT_VALUE_ROOM], axisLabel: { ...composedX.axisLabel, hideOverlap: true } }
+        ? { ...composedX, boundaryGap: [...DOTPLOT_VALUE_ROOM], axisLabel: { ...parseUnknownRecord(composedX.axisLabel), hideOverlap: true } }
         : composedX;
     const drawn = {
         ...option,
@@ -197,7 +208,7 @@ function deriveDotplot(block, rows, context) {
         xAxis,
         yAxis,
         visualMap: keys,
-        ...(graphic.length > 0 ? { graphic } : {}),
+        graphic,
         legend: { show: false },
         // The grid holds its labels and its titles inside the chart, as the runtime does by default.
         grid: { right: DOTPLOT_KEY_BAND },
@@ -218,17 +229,19 @@ function drawnMembers(series, dimension) {
 }
 /** The smallest of some values, or zero for none. */
 function lowestOf(values) {
-    let low = values.length > 0 ? values[0] : 0;
-    for (const value of values)
-        if (value < low)
+    let low;
+    for (const value of values) {
+        if (low === undefined || value < low)
             low = value;
-    return low;
+    }
+    return low ?? 0;
 }
 /** The largest of some values, or one for none. */
 function highestOf(values) {
-    let high = values.length > 0 ? values[0] : 1;
-    for (const value of values)
-        if (value > high)
+    let high;
+    for (const value of values) {
+        if (high === undefined || value > high)
             high = value;
-    return high;
+    }
+    return high ?? 1;
 }

package/dist/report-render/figures/embedding.js

@@ -18,6 +18,8 @@
 import { err, ok } from "neverthrow";
 import { channelColumn, channelOrder, channelTransform } from "../../contracts/report-blocks.js";
 import { declaredForColumn } from "../../contracts/report-reference.js";
+import { isUnknownArray } from "../../lib/unknown-array.js";
+import { parseUnknownRecord } from "../../lib/unknown-containers.js";
 import { CHART_INK, CHART_PAGE_TEXT_PX, DIVERGING_RAMP, SEQUENTIAL_RAMP } from "../design.js";
 import { categoricalPalette, categoryName, chartProblem, colorScale, firstAppearance, toNumber, transformColumn, valueAxisTitle } from "./common.js";
 import { equalRanges, squareLayout } from "./equal-units.js";
@@ -120,13 +122,13 @@ function deriveEmbedding(block, rows, context) {
                 encoding: {
                     x,
                     y,
-                    ...(group !== undefined ? { group } : {}),
-                    ...(color !== undefined ? { color } : {}),
-                    ...(label !== undefined ? { label } : {}),
+                    group,
+                    color,
+                    label,
                 },
             },
         ],
-        ...(facet !== undefined ? { facet } : {}),
+        facet,
     };
     const composed = context.compose(composition, color !== undefined ? { colorOnTop: true } : {});
     if (composed.isErr())
@@ -157,22 +159,23 @@ function deriveEmbedding(block, rows, context) {
             x: px,
             y: py,
             panel: facetCell === null ? 0 : (panelOf.get(`${typeof facetCell}:${String(facetCell)}`) ?? 0),
-            ...(cellGroup !== null ? { group: categoryName(cellGroup) } : {}),
-            ...(cellColor !== null ? { color: cellColor } : {}),
+            group: cellGroup === null ? undefined : categoryName(cellGroup),
+            color: cellColor ?? undefined,
         });
     }
     const option = composed.value;
     const panels = Math.max(1, panelNames.length);
     const pointPx = embeddingPointPx(cells.length);
-    const series = (Array.isArray(option.series) ? option.series : []).map((entry) => ({
-        ...entry,
-        large: color === undefined && cells.length >= EMBEDDING_LARGE_CELLS,
-        symbolSize: pointPx,
-        itemStyle: {
-            ...(typeof entry.itemStyle === "object" && entry.itemStyle !== null ? entry.itemStyle : {}),
-            opacity: EMBEDDING_OPACITY,
-        },
-    }));
+    const series = (isUnknownArray(option.series) ? option.series : []).map((entry) => {
+        const fields = parseUnknownRecord(entry) ?? {};
+        const itemStyle = parseUnknownRecord(fields.itemStyle);
+        return {
+            ...fields,
+            large: color === undefined && cells.length >= EMBEDDING_LARGE_CELLS,
+            symbolSize: pointPx,
+            itemStyle: itemStyle === undefined ? { opacity: EMBEDDING_OPACITY } : { ...itemStyle, opacity: EMBEDDING_OPACITY },
+        };
+    });
     const ranges = equalRanges(cells.map((cell) => cell.x), cells.map((cell) => cell.y), { pad: EMBEDDING_PAD, round: false });
     const scaleTitle = color !== undefined ? valueAxisTitle(context.labels, channelName(color)) : "";
     const scaleBand = Math.max(EMBEDDING_SCALE_BAND_PX, Math.ceil(scaleTitle.length * CHART_PAGE_TEXT_PX * SCALE_CHARACTER_SHARE) + SCALE_BAND_PAD_PX);
@@ -188,34 +191,36 @@ function deriveEmbedding(block, rows, context) {
     const keyStyle = { color: CHART_INK, align: "left" };
     for (let panel = 0; panel < panels; panel += 1) {
         const key = panel === 0;
+        const keyFields = key
+            ? {
+                name: `${valueAxisTitle(context.labels, channelName(x))}${KEY_ARROW}`,
+                nameLocation: "start",
+                nameGap: 0,
+                nameTextStyle: { ...keyStyle, verticalAlign: "top" },
+            }
+            : undefined;
         xAxes.push({
             type: "value",
             gridIndex: panel,
             ...ranges.x,
             ...HIDDEN_AXIS_PARTS,
-            ...(key
-                ? {
-                    name: `${valueAxisTitle(context.labels, channelName(x))}${KEY_ARROW}`,
-                    nameLocation: "start",
-                    nameGap: 0,
-                    nameTextStyle: { ...keyStyle, verticalAlign: "top" },
-                }
-                : {}),
+            ...keyFields,
         });
+        const yKeyFields = key
+            ? {
+                name: `${valueAxisTitle(context.labels, channelName(y))}${KEY_ARROW}`,
+                nameLocation: "start",
+                nameRotate: 90,
+                nameGap: 0,
+                nameTextStyle: { ...keyStyle, verticalAlign: "bottom" },
+            }
+            : undefined;
         yAxes.push({
             type: "value",
             gridIndex: panel,
             ...ranges.y,
             ...HIDDEN_AXIS_PARTS,
-            ...(key
-                ? {
-                    name: `${valueAxisTitle(context.labels, channelName(y))}${KEY_ARROW}`,
-                    nameLocation: "start",
-                    nameRotate: 90,
-                    nameGap: 0,
-                    nameTextStyle: { ...keyStyle, verticalAlign: "bottom" },
-                }
-                : {}),
+            ...yKeyFields,
         });
     }
     // Each panel names its facet value on an axis of no series over its square, thus the name moves with the square.
@@ -232,7 +237,7 @@ function deriveEmbedding(block, rows, context) {
         });
     }
     const out = {
-        ...(option.tooltip !== undefined ? { tooltip: option.tooltip } : {}),
+        tooltip: option.tooltip,
         grid: layout.grid,
         xAxis: xAxes,
         yAxis: yAxes,
@@ -248,9 +253,11 @@ function deriveEmbedding(block, rows, context) {
             series: [...series, ...nameSeries(cells, names, panels, ranges)],
         });
     }
-    const colorChannel = color;
-    const map = clippedScale(cells.flatMap((cell) => (cell.color === undefined ? [] : [cell.color])), scaleTitle, channelName(colorChannel), declaredForColumn(context.meanings, channelColumn(colorChannel)));
-    const composedMaps = Array.isArray(option.visualMap) ? option.visualMap : [];
+    if (color === undefined) {
+        return err(chartProblem(block.id, 'The embedding colors its cells by a "group" channel or by a "color" channel. Name one of the two.'));
+    }
+    const map = clippedScale(cells.flatMap((cell) => (cell.color === undefined ? [] : [cell.color])), scaleTitle, channelName(color), declaredForColumn(context.meanings, channelColumn(color)));
+    const composedMaps = isUnknownArray(option.visualMap) ? option.visualMap.map((entry) => parseUnknownRecord(entry) ?? {}) : [];
     const seriesIndex = composedMaps.find((entry) => entry.dimension === 2)?.seriesIndex ?? series.map((_entry, index) => index);
     const place = layout.visualMap?.[0] ?? {};
     return ok({ ...out, visualMap: [{ type: "continuous", seriesIndex, dimension: 2, ...map, ...place }] });
@@ -265,7 +272,8 @@ function deriveEmbedding(block, rows, context) {
  */
 function clippedScale(values, title, column, meaning) {
     const sorted = [...values].sort((a, b) => a - b);
-    const negative = sorted.length > 0 && sorted[0] < 0;
+    const first = sorted[0];
+    const negative = first !== undefined && first < 0;
     if (negative) {
         const reach = quantile(values.map((value) => Math.abs(value)).sort((a, b) => a - b), EMBEDDING_CLIP_QUANTILE);
         const end = reach > 0 ? reach : 1;
@@ -273,7 +281,8 @@ function clippedScale(values, title, column, meaning) {
     }
     const positive = sorted.find((value) => value > 0);
     const clip = quantile(sorted, EMBEDDING_CLIP_QUANTILE);
-    const top = clip > 0 ? clip : (sorted[sorted.length - 1] ?? 0) > 0 ? sorted[sorted.length - 1] : 1;
+    const last = sorted[sorted.length - 1];
+    const top = clip > 0 ? clip : last !== undefined && last > 0 ? last : 1;
     const low = positive === undefined ? top : Math.min(positive, top);
     return {
         ...withoutRight(colorScale({ min: 0, max: top, ramp: SEQUENTIAL_RAMP }, title, column, meaning)),
@@ -290,12 +299,12 @@ function withoutRight(map) {
  * The linear quantile of sorted values, as numpy and R type 7 give it. An empty list gives zero.
  */
 function quantile(sorted, p) {
-    if (sorted.length === 0)
-        return 0;
     const place = (sorted.length - 1) * p;
-    const low = Math.floor(place);
-    const high = Math.ceil(place);
-    return sorted[low] + (sorted[high] - sorted[low]) * (place - low);
+    const low = sorted[Math.floor(place)];
+    const high = sorted[Math.ceil(place)];
+    if (low === undefined || high === undefined)
+        return 0;
+    return low + (high - low) * (place - Math.floor(place));
 }
 /**
  * The series of the category names on the data: one name for each category of each panel, at the median x and

package/dist/report-render/figures/equal-units.d.ts

@@ -23,14 +23,14 @@
  */
 import type { EchartOption } from "../chart.js";
 /** The margins around the squares, in pixels at the page text size. */
-export interface SquareMargins {
+export type SquareMargins = {
     readonly top: number;
     readonly bottom: number;
     readonly left: number;
     readonly right: number;
-}
+};
 /** What one square layout places: the panels, their margins, and the members of the band at their right. */
-export interface SquareLayoutFields {
+export type SquareLayoutFields = {
     readonly panels: number;
     readonly margins: SquareMargins;
     /** The width in pixels of the band at the right of the squares, or 0 for no band. */
@@ -61,14 +61,14 @@ export interface SquareLayoutFields {
         readonly series: number;
         readonly insetPx: number;
     };
-}
+};
 /** The grids of a square layout, the places of the band members, and the media rules that resize them. */
-export interface SquareLayout {
+export type SquareLayout = {
     readonly grid: EchartOption[];
     readonly legend?: EchartOption;
     readonly visualMap?: EchartOption[];
     readonly media: EchartOption[];
-}
+};
 /**
  * The layout of some square panels, and of the band at their right.
  *
@@ -77,16 +77,16 @@ export interface SquareLayout {
  */
 export declare function squareLayout(fields: SquareLayoutFields): SquareLayout;
 /** The range of one axis. */
-export interface AxisRange {
+export type AxisRange = {
     readonly min: number;
     readonly max: number;
-}
+};
 /** The ranges of the two axes of one unit, and the tick step of a rounded pair. */
-export interface EqualRanges {
+export type EqualRanges = {
     readonly x: AxisRange;
     readonly y: AxisRange;
     readonly step?: number;
-}
+};
 /**
  * The ranges of two axes that share one unit: each axis spans one length, around its own data.
  *

package/dist/report-render/figures/equal-units.js

@@ -61,7 +61,7 @@ const POINT_MIN_PX = 1;
  */
 export function squareLayout(fields) {
     const placements = SQUARE_SIDES.map((side) => placement(side, fields, marginScale(side), TOOLBOX_BAND_PX));
-    const smallest = placements[0];
+    const smallest = placements[0] ?? placement(SQUARE_MIN_PX, fields, marginScale(SQUARE_MIN_PX), TOOLBOX_BAND_PX);
     const media = placements.map((entry, index) => ({
         // The first rule matches every container, thus a container that shrinks past a rule falls back to it.
         query: index === 0 ? { minWidth: 0 } : { minWidth: entry.minWidth, minHeight: entry.minHeight },
@@ -70,7 +70,7 @@ export function squareLayout(fields) {
     for (const size of EXPORT_SIZES) {
         const scale = size.textPx / CHART_PAGE_TEXT_PX;
         const fitting = SQUARE_SIDES.map((side) => placement(side, fields, scale, 0)).filter((entry) => entry.minWidth <= size.widthPx && entry.minHeight <= size.heightPx);
-        const chosen = fitting.length > 0 ? fitting[fitting.length - 1] : placement(SQUARE_MIN_PX, fields, scale, 0);
+        const chosen = fitting[fitting.length - 1] ?? placement(SQUARE_MIN_PX, fields, scale, 0);
         media.push({
             query: { minWidth: size.widthPx, maxWidth: size.widthPx, minHeight: size.heightPx, maxHeight: size.heightPx },
             option: placedOption(shifted(chosen, Math.max(0, Math.floor((size.widthPx - chosen.minWidth) / 2)))),
@@ -78,8 +78,8 @@ export function squareLayout(fields) {
     }
     return {
         grid: smallest.grid,
-        ...(smallest.legend !== undefined ? { legend: smallest.legend } : {}),
-        ...(smallest.visualMap !== undefined ? { visualMap: smallest.visualMap } : {}),
+        legend: smallest.legend,
+        visualMap: smallest.visualMap,
         media,
     };
 }
@@ -92,20 +92,20 @@ function marginScale(side) {
 /** The option of one media rule: the point size, the grids, the legend, and the color scales of one placement. */
 function placedOption(entry) {
     return {
-        ...(entry.series !== undefined ? { series: entry.series } : {}),
+        series: entry.series,
         grid: entry.grid,
-        ...(entry.legend !== undefined ? { legend: entry.legend } : {}),
-        ...(entry.visualMap !== undefined ? { visualMap: entry.visualMap } : {}),
+        legend: entry.legend,
+        visualMap: entry.visualMap,
     };
 }
 /** One placement moved right by some pixels: each grid, the legend, and each color scale. */
 function shifted(entry, by) {
-    const move = (member) => ({ ...member, left: member.left + by });
+    const move = (member) => ({ ...member, left: Number(member.left) + by });
     return {
         ...entry,
         grid: entry.grid.map(move),
-        ...(entry.legend !== undefined ? { legend: move(entry.legend) } : {}),
-        ...(entry.visualMap !== undefined ? { visualMap: entry.visualMap.map(move) } : {}),
+        legend: entry.legend === undefined ? undefined : move(entry.legend),
+        visualMap: entry.visualMap?.map(move),
     };
 }
 /**
@@ -136,8 +136,8 @@ function placement(side, fields, scale, leastTop) {
     const pointPx = points === undefined ? 0 : Math.max(POINT_MIN_PX, Math.round(points.px * Math.min(1, side / POINT_SCALE_FROM_PX) * 10) / 10);
     const squareLabel = fields.squareLabel;
     const series = Array.from({ length: Math.max(points?.series ?? 0, squareLabel === undefined ? 0 : squareLabel.series + 1) }, (_entry, index) => ({
-        ...(points !== undefined && index < points.series ? { symbolSize: pointPx } : {}),
-        ...(squareLabel !== undefined && index === squareLabel.series ? { label: { width: side - 2 * squareLabel.insetPx, overflow: "break" } } : {}),
+        symbolSize: points !== undefined && index < points.series ? pointPx : undefined,
+        label: squareLabel !== undefined && index === squareLabel.series ? { width: side - 2 * squareLabel.insetPx, overflow: "break" } : undefined,
     }));
     const blockBottom = top + rows * side + (rows - 1) * gap + margin(fields.margins.bottom);
     const bottomBand = fields.legendBand;
@@ -149,12 +149,10 @@ function placement(side, fields, scale, leastTop) {
             ? { legend: { left: bandLeft, top } }
             : { legend: { left, top: blockBottom, width: blockRight - left, orient: "horizontal" } };
     return {
-        ...(series.length > 0 ? { series } : {}),
+        series,
         grid,
         ...legend,
-        ...(fields.visualMaps !== undefined && fields.visualMaps > 0
-            ? { visualMap: Array.from({ length: fields.visualMaps }, () => ({ left: bandLeft, top })) }
-            : {}),
+        visualMap: Array.from({ length: fields.visualMaps ?? 0 }, () => ({ left: bandLeft, top })),
         minWidth: blockRight + band + margin(fields.margins.right),
         minHeight: blockBottom + legendHeight,
     };
@@ -176,26 +174,28 @@ export function equalRanges(xs, ys, fields) {
         return { x: around(x, length), y: around(y, length) };
     }
     const step = roundStep(length / 5);
-    const snapped = [x, y].map((range) => ({ min: Math.floor(range.min / step), max: Math.ceil(range.max / step) }));
-    const steps = Math.max(...snapped.map((range) => range.max - range.min), 1);
-    const [xRange, yRange] = snapped.map((range) => {
+    const snap = (range) => ({ min: Math.floor(range.min / step), max: Math.ceil(range.max / step) });
+    const xSnapped = snap(x);
+    const ySnapped = snap(y);
+    const steps = Math.max(xSnapped.max - xSnapped.min, ySnapped.max - ySnapped.min, 1);
+    const widen = (range) => {
         const short = steps - (range.max - range.min);
         return { min: exact((range.min - Math.ceil(short / 2)) * step), max: exact((range.max + Math.floor(short / 2)) * step) };
-    });
-    return { x: xRange, y: yRange, step };
+    };
+    return { x: widen(xSnapped), y: widen(ySnapped), step };
 }
 /** The extent of some values, or the unit range for no value. */
 function extent(values) {
-    if (values.length === 0)
-        return { min: 0, max: 1 };
-    let min = values[0];
-    let max = values[0];
+    let min;
+    let max;
     for (const value of values) {
-        if (value < min)
+        if (min === undefined || value < min)
             min = value;
-        if (value > max)
+        if (max === undefined || value > max)
             max = value;
     }
+    if (min === undefined || max === undefined)
+        return { min: 0, max: 1 };
     return { min, max };
 }
 /** One range of the given length around the middle of an extent. */