@macrostrat/column-views 3.11.0 → 3.12.0

package/src/data-provider/store.ts

@@ -2,8 +2,10 @@ import {
   createContext,
   ReactNode,
   RefObject,
+  useCallback,
   useContext,
   useMemo,
+  useState,
 } from "react";
 import h from "@macrostrat/hyper";
 import {
@@ -188,11 +190,58 @@ export function MacrostratColumnDataProvider<T extends BaseUnit>({
     },
     [
       h(ColumnRefManager, { ref }),
-      h(MacrostratColumnDataContext.Provider, { value }, children),
+      h(
+        MacrostratColumnDataContext.Provider,
+        { value },
+        h(ColumnLayoutOverridesProvider, null, children),
+      ),
     ],
   );
 }
 
+/* Layout overrides requested by a column's children. A layer that draws its
+ * own labels beside the units (the surfaces view) claims the label column, so
+ * the unit labels give way: it is one set of labels or the other. */
+
+interface ColumnLayoutOverrides {
+  /** How many children currently claim the label column */
+  labelColumnClaims: number;
+  claimLabelColumn(): () => void;
+}
+
+const ColumnLayoutOverridesContext = createContext<ColumnLayoutOverrides>({
+  labelColumnClaims: 0,
+  claimLabelColumn: () => () => {},
+});
+
+function ColumnLayoutOverridesProvider({ children }: { children: ReactNode }) {
+  const [labelColumnClaims, setClaims] = useState(0);
+  const claimLabelColumn = useCallback(() => {
+    setClaims((n) => n + 1);
+    return () => setClaims((n) => Math.max(n - 1, 0));
+  }, []);
+  const value = useMemo(
+    () => ({ labelColumnClaims, claimLabelColumn }),
+    [labelColumnClaims, claimLabelColumn],
+  );
+  return h(ColumnLayoutOverridesContext.Provider, { value }, children);
+}
+
+/** Claim the column's label column for this component while it is mounted:
+ * the unit labels are hidden in favor of whatever the caller draws there. */
+export function useClaimLabelColumn(active: boolean = true) {
+  const { claimLabelColumn } = useContext(ColumnLayoutOverridesContext);
+  useEffect(() => {
+    if (!active) return;
+    return claimLabelColumn();
+  }, [active, claimLabelColumn]);
+}
+
+/** Whether a child of the column has claimed the label column */
+export function useLabelColumnClaimed(): boolean {
+  return useContext(ColumnLayoutOverridesContext).labelColumnClaims > 0;
+}
+
 function ColumnRefManager({ ref }: { ref?: RefObject<ColumnRef> }) {
   const selectedUnitElement = scope.useAtomValue(selectedUnitElementAtom);
   useEffect(() => {

package/src/index.ts

@@ -3,9 +3,13 @@ export * from "./data-provider";
 export * from "./age-axis";
 export * from "./prepare-units";
 export * from "./animated-age-window";
+export * from "./timescale-zoom";
 export * from "./column";
+// The timescale column on its own: a view can add one per timescale its data
+// refers to, drawn against the same section scales
+export { CompositeTimescale, CompositeTimescaleCore } from "./section";
 export * from "./unit-details";
-export * from "./age-model-overlay";
+export * from "./age-model";
 export * from "./correlation-chart";
 export * from "./notes";
 export * from "./facets";

package/src/notes.ts

@@ -2,7 +2,7 @@ import h from "@macrostrat/hyper";
 
 import { ColumnNotesProvider } from "./units";
 
-import { NotesColumn, SVG } from "@macrostrat/column-components";
+import { NotesColumn, SVG, type NoteData } from "@macrostrat/column-components";
 import { useCompositeScale, useMacrostratColumnData } from "./data-provider";
 import type { ComponentType, ReactNode } from "react";
 
@@ -14,6 +14,15 @@ interface ColumnNotesProps {
   deltaConnectorAttachment?: number;
   children?: ReactNode;
   focusedNoteComponent?: ComponentType<any> | null;
+  /** Called when a note is clicked */
+  onClickNote?: (note: NoteData) => void;
+  /** Px the connector continues past each end (see `NodeConnectorOptions`) */
+  connectorOverhang?: number | [number, number];
+  /** Draw the marker at a point note's height (default true) */
+  showPointMarker?: boolean;
+  /** Options for the label force layout (e.g. `nodeSpacing`) */
+  forceOptions?: object;
+  className?: string;
 }
 
 export function ColumnNotes({
@@ -23,6 +32,11 @@ export function ColumnNotes({
   paddingLeft = 60,
   deltaConnectorAttachment,
   focusedNoteComponent,
+  onClickNote,
+  forceOptions,
+  connectorOverhang,
+  showPointMarker,
+  className,
   children,
 }: ColumnNotesProps) {
   const { totalHeight } = useMacrostratColumnData();
@@ -36,7 +50,7 @@ export function ColumnNotes({
       pixelScale: -1,
     },
     [
-      h(SVG, { width, height: totalHeight, paddingH: 4 }, [
+      h(SVG, { width, height: totalHeight, paddingH: 4, className }, [
         h(NotesColumn, {
           width,
           notes,
@@ -44,6 +58,10 @@ export function ColumnNotes({
           paddingLeft,
           deltaConnectorAttachment,
           focusedNoteComponent,
+          onClickNote,
+          forceOptions,
+          connectorOverhang,
+          showPointMarker,
         }),
       ]),
       children,

package/src/prepare-units/composite-scale.ts

@@ -3,6 +3,7 @@ import { agesOverlap, ensureArray, getUnitHeightRange } from "./utils";
 import { ScaleContinuousNumeric, scaleLinear } from "d3-scale";
 import { UnitLong } from "@macrostrat/api-types";
 import { buildHybridScale } from "./dynamic-scales";
+import { sectionDensity } from "./density";
 import { ExtUnit, HybridScaleType, SectionInfo } from "./types";
 import type {
   ColumnScaleOptions,
@@ -120,6 +121,7 @@ function addScaleToSection<T extends UnitLong = ExtUnit>(
   const scaleInfo = buildSectionScale<T>(units, {
     ...opts,
     domain: _range,
+    sectionID: group.section_id,
   });
 
   return {
@@ -134,18 +136,17 @@ function buildSectionScale<T extends UnitLong>(
 ): PackageScaleInfo {
   const {
     targetUnitHeight = 20,
-    minPixelScale = 0.2,
     axisType,
-    minSectionHeight,
     visibleWindow,
     scale,
     hybridScale,
+    sectionID,
   } = opts;
   const domain = opts.domain ?? findSectionHeightRange(data, axisType);
 
   const dAge = Math.abs(domain[0] - domain[1]);
 
-  let _pixelScale = opts.pixelScale;
+  let _pixelScale: any = opts.pixelScale;
   let pixelHeight: number;
 
   if (hybridScale != null) {
@@ -154,7 +155,12 @@ function buildSectionScale<T extends UnitLong>(
      * This is somewhat like an ordinal scale
      */
     if (hybridScale.type === HybridScaleType.EquidistantSurfaces) {
+      // Pixels between one surface and the next: neither axis's units
       _pixelScale ??= targetUnitHeight;
+    } else {
+      // An approximate-height column is drawn from measured thickness, so it
+      // is metres per pixel whatever the axis is labeled in
+      _pixelScale = opts.pixelsPerMeter ?? _pixelScale;
     }
 
     return buildHybridScale(hybridScale, data, domain, {
@@ -164,27 +170,19 @@ function buildSectionScale<T extends UnitLong>(
   }
 
   if (scale == null) {
-    if (_pixelScale == null) {
-      const avgAgeRange = findAverageUnitHeight(data, axisType, visibleWindow);
-      // Get pixel height necessary to render average unit at target height
-      _pixelScale = Math.max(targetUnitHeight / avgAgeRange, minPixelScale);
-
-      // OLD METHOD that cares about overall section height vs. individual unit height
-      // 0.2 pixel per myr is the floor scale
-      //const targetHeight = targetUnitHeight * data.length;
-      // 1 pixel per myr is the floor scale
-      //_pixelScale = Math.max(targetHeight / dAge, minPixelScale);
-    }
-
-    let height = dAge * _pixelScale;
-    // If height is less than minSectionHeight, set it to minSectionHeight.
-    // Sections reach here at their *full* extent (the rendered window is applied
-    // afterwards, by `trimSectionsToWindow`), so this floor only ever inflates a
-    // genuinely small section — which is what it's for — and never a sliver that
-    // the window happens to cut.
-    const _minSectionHeight = minSectionHeight ?? targetUnitHeight ?? 0;
-    pixelHeight = Math.max(height, _minSectionHeight);
-    _pixelScale = pixelHeight / dAge;
+    /** Every rule that sets a section's height resolves to one density (see
+     * `./density`). Sections reach here at their *full* extent — the rendered
+     * window is applied afterwards, by `trimSectionsToWindow` — so a floor on
+     * the section's height only ever inflates a genuinely small section, which
+     * is what it's for, and never a sliver the window happens to cut. */
+    _pixelScale = sectionDensity(opts)({
+      extent: dAge,
+      unitExtents: visibleUnitExtents(data, axisType, visibleWindow),
+      units: data,
+      sectionID,
+      axisType,
+    });
+    pixelHeight = dAge * _pixelScale;
   } else {
     // If a scale is provided, use it to compute pixel height
     pixelHeight = Math.abs(scale(domain[0]) - scale(domain[1]));
@@ -429,12 +427,12 @@ function findSectionHeightRange(
   }
 }
 
-function findAverageUnitHeight(
+function visibleUnitExtents(
   data: UnitLong[],
   axisType: ColumnAxisType,
   visibleWindow?: [number, number] | null,
-): number {
-  /** The typical duration of a unit, which `targetUnitHeight` sizes.
+): number[] {
+  /** The durations of the units a density rule gets to size.
    *
    * Measured over what the render window actually *shows* — units outside it
    * are ignored and a unit it cuts through counts only for its visible part.
@@ -463,9 +461,7 @@ function findAverageUnitHeight(
   const useWindow = visibleWindow != null && axisType === ColumnAxisType.AGE;
   let heights = useWindow ? durations(true) : [];
   if (heights.length === 0) heights = durations(false);
-  if (heights.length === 0) return 1;
-
-  return heights.reduce((a, b) => a + b, 0) / heights.length;
+  return heights;
 }
 
 export interface CompositeColumnScale {
@@ -593,7 +589,14 @@ export function collapseUnconformitiesByPixelHeight<T extends UnitLong>(
       _diff(heights.map(currentSection.scaleInfo.scale)),
     ];
 
-    const pxHeight = Math.min(...pxHeights);
+    /** The gap has no density of its own — it falls between two sections that
+     * may be drawn at very different ones — so it is judged at the finer of
+     * the two. Taking the smaller estimate let a sparse neighbor speak for a
+     * gap the other neighbor would have drawn many times larger: a 16 Myr
+     * hiatus in column 22 read as 26px against one section and 166px against
+     * the other, and collapsed. A gap is only worth hiding when neither scale
+     * would give it more room than the break that replaces it. */
+    const pxHeight = Math.max(...pxHeights);
 
     if (pxHeight < threshold) {
       let t_pos: number;

package/src/prepare-units/density.ts

@@ -0,0 +1,197 @@
+/** How tall a column draws comes down to one quantity: **density**, the pixels
+ * given to one unit of the axis — a Myr on an age column, a metre otherwise.
+ *
+ * Every option that sets a column's height names that quantity. Most are
+ * floors, differing only in the units they're stated in: room for a unit,
+ * for a section, or for the density itself. They combine by taking the
+ * largest, so each says "at least this much", whichever ends up binding.
+ */
+import { ColumnAxisType } from "@macrostrat/column-components";
+import type { UnitLong } from "@macrostrat/api-types";
+
+export interface SectionDensityContext {
+  /** The section's extent, in axis units */
+  extent: number;
+  /** Extents of the units the render window actually shows, each clipped to
+   * it. Measuring what's on screen is what makes a unit-height rule mean the
+   * same thing at every zoom depth. */
+  unitExtents: number[];
+  /** The section's units, unclipped, for a rule that needs more than their
+   * extents */
+  units: UnitLong[];
+  sectionID?: number;
+  axisType: ColumnAxisType;
+}
+
+/** Pixels per axis unit, for one section */
+export type SectionDensity = (ctx: SectionDensityContext) => number;
+
+export type SectionDensityLike = number | SectionDensity;
+
+/** Room for a typical unit on screen: `px` tall, whatever its duration.
+ *
+ * "Typical" is the median of the visible extents, which is the only summary
+ * that survives both tails. Unit durations are spread over orders of
+ * magnitude: the arithmetic mean sits above any unit you would point at, so a
+ * couple of long ones squeeze everything else below the target — and the
+ * geometric mean fails the other way, since a single hair-thin unit (a
+ * Holocene sliver beside a Pliocene terrace, say) drags the log-average down
+ * and stretches the whole section to give that sliver its 20 pixels.
+ */
+export function unitHeight(px: number): SectionDensity {
+  return (ctx) => px / typicalExtent(ctx.unitExtents);
+}
+
+/** Room for the section: `px` tall, whatever its extent. */
+export function sectionHeight(px: number): SectionDensity {
+  return (ctx) => px / ctx.extent;
+}
+
+/** A density stated outright, in pixels per axis unit. */
+export function fixedDensity(px: number): SectionDensity {
+  return () => px;
+}
+
+/** The rule that asks for the most room. Rules that don't resolve to a finite
+ * number — a section of no extent, a window showing no units — are passed
+ * over rather than swallowing the rest. */
+export function atLeast(...rules: SectionDensityLike[]): SectionDensity {
+  return (ctx) => {
+    let density = 0;
+    for (const rule of rules) {
+      const value = resolveDensity(rule, ctx);
+      if (!Number.isFinite(value)) continue;
+      density = Math.max(density, value);
+    }
+    return density;
+  };
+}
+
+export function resolveDensity(
+  rule: SectionDensityLike,
+  ctx: SectionDensityContext,
+): number {
+  if (typeof rule === "number") return rule;
+  return rule(ctx);
+}
+
+function typicalExtent(extents: number[]): number {
+  const sorted = extents.filter((d) => d > 0).sort((a, b) => a - b);
+  if (sorted.length === 0) return NaN;
+  const mid = (sorted.length - 1) / 2;
+  const lower = Math.floor(mid);
+  const upper = Math.ceil(mid);
+  return (sorted[lower] + sorted[upper]) / 2;
+}
+
+/** Mirrors the default in `sectionDensity` */
+export const DEFAULT_TARGET_UNIT_HEIGHT = 20;
+/** Small sections often have a unit or two, and no room for axis labels */
+const DEFAULT_MIN_PIXEL_SCALE = 0.2;
+
+/** What a section is sized by. Stated for the column as a whole, and again
+ * per section by `sectionOptions` where one needs different treatment. */
+export interface SectionSizeOptions {
+  /** A density stated outright, in pixels per axis unit: every section drawn
+   * to the same scale whatever it holds. Rarely what you want within one
+   * column, and the only way to make several of them comparable.
+   *
+   * Left out — the usual case — the density comes from the section's own
+   * units, via `targetUnitHeight` and the floors. Set, it *is* the density:
+   * the floors don't apply, since they would undo the scale you stated.
+   *
+   * It also takes a rule, for what the options here can't describe.
+   *
+   * This one is stated in whatever the axis measures, so it means a different
+   * thing on an age axis than on a depth one. A view that switches between
+   * them wants `pixelsPerMyr` and `pixelsPerMeter` instead. */
+  pixelScale?: SectionDensityLike;
+  /** Pixels per million years, on an age axis.
+   *
+   * The axis-specific spellings of `pixelScale`, and what to reach for when
+   * the axis can change under you: useful values differ by orders of
+   * magnitude between the two, so one number cannot serve both, any more than
+   * `t_age` could serve as `t_pos`. Both can be held at once — the axis picks
+   * — and either takes precedence over `pixelScale`. */
+  pixelsPerMyr?: number;
+  /** Pixels per metre, on a depth or height axis. Also the scale for an
+   * approximate-height column, whose units are metres of measured thickness
+   * however its axis is labeled. */
+  pixelsPerMeter?: number;
+  /** Room for a typical unit on screen. The knob that usually decides a
+   * column, and the one to reach for to draw it larger or smaller. */
+  targetUnitHeight?: number;
+  /** Room for a section, however little it holds */
+  minSectionHeight?: number;
+  /** A floor on the density itself */
+  minPixelScale?: number;
+}
+
+/** Sizing for one section, or a rule that works it out from what the section
+ * holds. What it returns overrides the column-wide options for that section;
+ * anything it leaves out keeps the column's value. */
+export type SectionOptionsLike =
+  | SectionSizeOptions
+  | ((ctx: SectionDensityContext) => SectionSizeOptions);
+
+export interface SectionDensityOptions extends SectionSizeOptions {
+  /** Sizing decided per section */
+  sectionOptions?: SectionOptionsLike;
+}
+
+/** The density rule a column uses, resolved per section so that
+ * `sectionOptions` gets to see a section before saying how to draw it. */
+export function sectionDensity(opts: SectionDensityOptions): SectionDensity {
+  const { sectionOptions } = opts;
+  if (sectionOptions == null) {
+    const rule = densityRule(opts);
+    return (ctx) => rule(ctx);
+  }
+
+  return (ctx) => {
+    let overrides = sectionOptions;
+    if (typeof sectionOptions === "function") overrides = sectionOptions(ctx);
+    return densityRule({ ...opts, ...overrides })(ctx);
+  };
+}
+
+/** The floors, combined: whichever asks for the most room wins. */
+function densityRule(opts: SectionSizeOptions): SectionDensity {
+  const {
+    targetUnitHeight = DEFAULT_TARGET_UNIT_HEIGHT,
+    minPixelScale = DEFAULT_MIN_PIXEL_SCALE,
+    minSectionHeight,
+  } = opts;
+
+  const derived = atLeast(
+    unitHeight(targetUnitHeight),
+    fixedDensity(minPixelScale),
+    sectionHeight(minSectionHeight ?? targetUnitHeight ?? 0),
+  );
+
+  return (ctx) => {
+    // A density given outright answers for the section by itself. The floors
+    // exist to keep a column readable when its own contents decide the
+    // density; a scale you stated is a decision already made, and a floor
+    // would quietly undo it — which is the whole point of stating one,
+    // usually so that several columns can be compared.
+    const stated = statedDensity(opts, ctx.axisType);
+    if (typeof stated === "function") return stated(ctx);
+    if (stated != null) return stated;
+    return derived(ctx);
+  };
+}
+
+/** The density this axis was given, if any. The axis-specific spellings win
+ * over the generic one, which is what lets both be held while the axis
+ * changes. */
+export function statedDensity(
+  opts: SectionSizeOptions,
+  axisType: ColumnAxisType,
+): SectionDensityLike | undefined {
+  const { pixelScale, pixelsPerMyr, pixelsPerMeter } = opts;
+  if (axisType === ColumnAxisType.AGE) {
+    return pixelsPerMyr ?? pixelScale;
+  }
+  return pixelsPerMeter ?? pixelScale;
+}

package/src/prepare-units/index.ts

@@ -27,10 +27,11 @@ import {
   PreparedColumnData,
   unitsOverlap,
 } from "./utils";
-import { SectionInfo } from "./types";
+import { type ColumnHeightScaleOptions, SectionInfo } from "./types";
 
 export * from "./utils";
 export * from "./types";
+export * from "./density";
 export { preprocessUnits };
 export type { CompositeColumnScale };
 
@@ -92,14 +93,28 @@ export function prepareColumnUnits(
   // also set up some values for eODP-style columns
   let units1 = units.map(preprocessSectionUnit);
 
-  if (clipBeforeLayout) {
+  /** A bound that isn't set doesn't bound anything. Passing `null` for one is
+   * the ordinary way to say "no window", and comparing against it as though
+   * it were an age would throw every unit out. */
+  const window = {
+    t_age: t_age ?? -Infinity,
+    b_age: b_age ?? Infinity,
+    t_pos: t_pos ?? -Infinity,
+    b_pos: b_pos ?? Infinity,
+  };
+  const isWindowed =
+    axisType == ColumnAxisType.AGE
+      ? t_age != null || b_age != null
+      : t_pos != null || b_pos != null;
+
+  if (clipBeforeLayout && isWindowed) {
     /** Prototype filtering to age range */
     units1 = units1.filter((d) => {
       // Filter units by t_age and b_age, inclusive
       if (axisType == ColumnAxisType.AGE) {
-        return agesOverlap(d, { t_age, b_age });
+        return agesOverlap(d, window);
       } else {
-        return unitsOverlap(d, { t_pos, b_pos } as any, axisType);
+        return unitsOverlap(d, window as any, axisType);
       }
     });
   }
@@ -207,11 +222,15 @@ export function prepareColumnUnits(
     // stretched to `minSectionHeight`), then spend the padding budget against
     // them, so a margin is the pixels asked for rather than those pixels times
     // whatever stretch its neighbor happened to need.
-    const floor = options.minSectionHeight ?? options.targetUnitHeight ?? 0;
+    const floor =
+      layoutOptions.minSectionHeight ?? layoutOptions.targetUnitHeight ?? 0;
     const scales = resolveWindowScales(sectionsWithScales, focalWindow, floor);
-    const scaleFor = (section) =>
+    const natural = (section) =>
       scales.get(section) ?? section.scaleInfo.pixelScale;
 
+
+    const scaleFor = natural;
+
     const window =
       windowPadding > 0
         ? padWindowByPixels(

package/src/prepare-units/types.ts

@@ -1,24 +1,33 @@
 import type { UnitLong } from "@macrostrat/api-types";
 import type { ColumnAxisType } from "@macrostrat/column-components";
 import type { ScaleContinuousNumeric } from "d3-scale";
+import type { SectionDensityLike, SectionOptionsLike } from "./density";
 
 export interface ColumnHeightScaleOptions {
-  /** A fixed pixel scale to use for the section (pixels per Myr) */
-  pixelScale?: number;
-  /** The target height of a constituent unit in pixels, for dynamic
-   * scale generation */
+  /** A density stated outright: pixels per Myr on an age column, per metre
+   * otherwise, every section drawn to the same scale whatever it holds.
+   * Rarely what you want within one column, and the only way to make several
+   * of them comparable.
+   *
+   * It also takes a rule — a function of the section's context — for the
+   * cases the options here can't describe. A rule is in sole charge of its
+   * section: the floors don't apply to it. */
+  pixelScale?: SectionDensityLike;
+  /** Room for a typical unit the render window shows: this many pixels tall,
+   * whatever its duration. The knob that usually decides a column — reach for
+   * it to draw one larger or smaller — and the one that expands it as you
+   * zoom in, since the units on screen keep their size while the time they
+   * cover shrinks. See `./density` for what "typical" means. */
   targetUnitHeight?: number;
-  /** Min height of a section in pixels. Will override minPixelScale in some cases. */
+  /** Room for a section: at least this many pixels tall, whatever its extent.
+   * Small sections have a unit or two and little room for axis labels. */
   minSectionHeight?: number;
-  /** The minimum pixel scale to use for the section (pixels per Myr). This is mostly
-   * needed because small sections (<1-2 units) don't necessarily have space to comfortably
-   * render two axis labels */
+  /** A floor on the density itself, in pixels per axis unit. */
   minPixelScale?: number;
-  /** The requested render window, `[b_age, t_age]`, if there is one. Set
-   * internally by `prepareColumnUnits`: unit density is derived from the units
-   * this window actually shows, so `targetUnitHeight` describes the units you
-   * can see at any zoom depth rather than the section's overall average. */
-  visibleWindow?: [number, number];
+  /** Sizing for a section in particular, or a rule that works it out from
+   * what the section holds. Whatever it returns overrides the options above
+   * for that section; anything it leaves out keeps the column's value. */
+  sectionOptions?: SectionOptionsLike;
   /** Padding around the `t_age`/`b_age` window, in **pixels** of neighboring
    * column: how much of the abutting sections to reveal past the window.
    *
@@ -76,6 +85,13 @@ export type HybridScaleDefinition =
 export interface SectionScaleOptions extends ColumnHeightScaleOptions {
   axisType: ColumnAxisType;
   domain: [number, number];
+  /** Named in the context a per-section rule sees */
+  sectionID?: number;
+  /** The requested render window, `[b_age, t_age]`, if there is one. Set
+   * internally by `prepareColumnUnits`: unit density is derived from the units
+   * this window actually shows, so `targetUnitHeight` describes the units you
+   * can see at any zoom depth rather than the section's overall average. */
+  visibleWindow?: [number, number];
 }
 
 /** Output of a section scale. For now, this assumes that the
@@ -141,6 +157,11 @@ export interface CompositeScaleData {
 export interface ColumnScaleOptions extends ColumnHeightScaleOptions {
   axisType: ColumnAxisType;
   unconformityHeight: number;
+  /** The requested render window, `[b_age, t_age]`, if there is one. Set
+   * internally by `prepareColumnUnits`: unit density is derived from the units
+   * this window actually shows, so `targetUnitHeight` describes the units you
+   * can see at any zoom depth rather than the section's overall average. */
+  visibleWindow?: [number, number];
 }
 
 export interface CompositeColumnData<T extends UnitLong = ExtUnit> extends Omit<