@macrostrat/column-views 3.8.0 → 3.10.0

package/dist/index.cjs

@@ -2,40 +2,33 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const index = require("./units/index.cjs");
 const ageAxis = require("./age-axis.cjs");
-const index$6 = require("./prepare-units/index.cjs");
+const index$3 = require("./prepare-units/index.cjs");
+const animatedAgeWindow = require("./animated-age-window.cjs");
 const column = require("./column.cjs");
 const ageModelOverlay = require("./age-model-overlay.cjs");
 const notes = require("./notes.cjs");
+const mapViews = require("@macrostrat/map-views");
 const ageRange = require("./unit-details/age-range.cjs");
 const composite = require("./units/composite.cjs");
-const columns = require("./maps/layers/columns.cjs");
 const base = require("./facets/measurements/base.cjs");
 const dataComponents = require("@macrostrat/data-components");
-const layers = require("./maps/column-navigation/svg/layers.cjs");
-const core = require("./maps/column-correlation/core.cjs");
-const state = require("./maps/column-correlation/state.cjs");
-const index$1 = require("./maps/column-navigation/mapbox/index.cjs");
 const columnNav = require("./data-provider/column-nav.cjs");
-const index$2 = require("./maps/column-navigation/svg/index.cjs");
 const main = require("./correlation-chart/main.cjs");
-const index$3 = require("./facets/detrital-zircon/index.cjs");
+const index$1 = require("./facets/detrital-zircon/index.cjs");
 const provider = require("./facets/fossils/provider.cjs");
 const types = require("./prepare-units/types.cjs");
-const index$4 = require("./maps/inset-map/index.cjs");
 const isotopesColumn = require("./facets/carbon-isotopes/isotopes-column.cjs");
 const panel = require("./unit-details/panel.cjs");
 const store = require("./data-provider/store.cjs");
-const units = require("./maps/layers/units.cjs");
 const dataProvider = require("./facets/carbon-isotopes/data-provider.cjs");
 const utils = require("./prepare-units/utils.cjs");
-const index$5 = require("./facets/fossils/index.cjs");
+const index$2 = require("./facets/fossils/index.cjs");
 const taxonRanges = require("./facets/fossils/taxon-ranges.cjs");
 const sgp = require("./facets/measurements/sgp.cjs");
 const stratNames = require("./unit-details/strat-names.cjs");
 const modalPanel = require("./unit-details/modal-panel.cjs");
 const popover = require("./unit-details/popover.cjs");
 const unitSelection = require("./data-provider/unit-selection.cjs");
-const colors = require("./units/colors.cjs");
 const hashString = require("./correlation-chart/hash-string.cjs");
 const helpers = require("./prepare-units/helpers.cjs");
 exports.BasicUnitComponent = index.BasicUnitComponent;
@@ -51,8 +44,9 @@ exports.ApproximateHeightAxis = ageAxis.ApproximateHeightAxis;
 exports.CompositeAgeAxis = ageAxis.CompositeAgeAxis;
 exports.CompositeAgeAxisCore = ageAxis.CompositeAgeAxisCore;
 exports.VerticalAxisLabel = ageAxis.VerticalAxisLabel;
-exports.prepareColumnUnits = index$6.prepareColumnUnits;
-exports.usePreparedColumnUnits = index$6.usePreparedColumnUnits;
+exports.prepareColumnUnits = index$3.prepareColumnUnits;
+exports.usePreparedColumnUnits = index$3.usePreparedColumnUnits;
+exports.useAnimatedAgeWindow = animatedAgeWindow.useAnimatedAgeWindow;
 exports.Column = column.Column;
 exports.ColumnBasicInfo = column.ColumnBasicInfo;
 exports.ColumnContainer = column.ColumnContainer;
@@ -73,9 +67,6 @@ exports.CompositeUnitsColumn = composite.CompositeUnitsColumn;
 exports.LabelTrackerProvider = composite.LabelTrackerProvider;
 exports.SectionLabelsColumn = composite.SectionLabelsColumn;
 exports.TrackedLabeledUnit = composite.TrackedLabeledUnit;
-exports.BaseColumnsLayer = columns.BaseColumnsLayer;
-exports.SelectedColumnOverlay = columns.SelectedColumnOverlay;
-exports.buildColumnsStyle = columns.buildColumnsStyle;
 exports.BaseMeasurementsColumn = base.BaseMeasurementsColumn;
 exports.TruncatedList = base.TruncatedList;
 exports.groupNotesByPixelDistance = base.groupNotesByPixelDistance;
@@ -93,32 +84,15 @@ Object.defineProperty(exports, "UnitIdentifier", {
   enumerable: true,
   get: () => dataComponents.UnitIdentifier
 });
-exports.ColumnCenters = layers.ColumnCenters;
-exports.ColumnFeatures = layers.ColumnFeatures;
-exports.ColumnKeyboardNavigation = layers.ColumnKeyboardNavigation;
-exports.Columns = layers.Columns;
-exports.CurrentColumn = layers.CurrentColumn;
-exports.MeasurementsLayer = layers.MeasurementsLayer;
-exports.ColumnCorrelationMap = core.ColumnCorrelationMap;
-exports.ColumnCorrelationProvider = state.ColumnCorrelationProvider;
-exports.useColumnMapLink = state.useColumnMapLink;
-exports.useCorrelationMapStore = state.useCorrelationMapStore;
-exports.ColumnHoverInteraction = index$1.ColumnHoverInteraction;
-exports.ColumnNavigationMap = index$1.ColumnNavigationMap;
-exports.ColumnSelectionManager = index$1.ColumnSelectionManager;
-exports.ColumnsNavigationLayer = index$1.ColumnsNavigationLayer;
 exports.ColumnNavProvider = columnNav.ColumnNavProvider;
 exports.useColumnNav = columnNav.useColumnNav;
-exports.ColumnNavigationSVGMap = index$2.ColumnNavigationSVGMap;
-exports.ResizableMapFrame = index$2.ResizableMapFrame;
 exports.CorrelationChart = main.CorrelationChart;
-exports.DetritalColumn = index$3.DetritalColumn;
-exports.DetritalGroup = index$3.DetritalGroup;
+exports.DetritalColumn = index$1.DetritalColumn;
+exports.DetritalGroup = index$1.DetritalGroup;
 exports.FossilDataType = provider.FossilDataType;
 exports.useFossilData = provider.useFossilData;
 exports.HeightMethod = types.HeightMethod;
 exports.HybridScaleType = types.HybridScaleType;
-exports.InsetMap = index$4.InsetMap;
 exports.IsotopesColumn = isotopesColumn.IsotopesColumn;
 exports.IsotopesDataset = isotopesColumn.IsotopesDataset;
 exports.LegendPanelHeader = panel.LegendPanelHeader;
@@ -138,8 +112,6 @@ exports.useColumnUnitsMap = store.useColumnUnitsMap;
 exports.useCompositeScale = store.useCompositeScale;
 exports.useMacrostratColumnData = store.useMacrostratColumnData;
 exports.useMacrostratUnits = store.useMacrostratUnits;
-exports.MacrostratUnitsOverlay = units.MacrostratUnitsOverlay;
-exports.buildUnitsStyle = units.buildUnitsStyle;
 exports.MeasurementDataContext = dataProvider.MeasurementDataContext;
 exports.MeasurementDataProvider = dataProvider.MeasurementDataProvider;
 exports.useMeasurementData = dataProvider.useMeasurementData;
@@ -151,7 +123,7 @@ exports.ensureRealFloat = utils.ensureRealFloat;
 exports.getPositionWithinUnit = utils.getPositionWithinUnit;
 exports.getUnitHeightRange = utils.getUnitHeightRange;
 exports.unitsOverlap = utils.unitsOverlap;
-exports.PBDBFossilsColumn = index$5.PBDBFossilsColumn;
+exports.PBDBFossilsColumn = index$2.PBDBFossilsColumn;
 exports.PBDBOccurrencesMatrix = taxonRanges.PBDBOccurrencesMatrix;
 exports.SGPMeasurementsColumn = sgp.SGPMeasurementsColumn;
 exports.StratNameField = stratNames.StratNameField;
@@ -169,10 +141,13 @@ exports.useSelectedUnit = unitSelection.useSelectedUnit;
 exports.useUnitSelection = unitSelection.useUnitSelection;
 exports.useUnitSelectionDispatch = unitSelection.useUnitSelectionDispatch;
 exports.useUnitSelectionTarget = unitSelection.useUnitSelectionTarget;
-exports.flattenLithologies = colors.flattenLithologies;
-exports.getMixedColorForData = colors.getMixedColorForData;
-exports.getMixedUnitColor = colors.getMixedUnitColor;
 exports.parseLineFromString = hashString.parseLineFromString;
 exports.stringifyLine = hashString.stringifyLine;
 exports.preprocessUnits = helpers.preprocessUnits;
+Object.keys(mapViews).forEach((k) => {
+  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: () => mapViews[k]
+  });
+});
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.d.ts

@@ -2,10 +2,12 @@ export * from './units';
 export * from './data-provider';
 export * from './age-axis';
 export * from './prepare-units';
+export * from './animated-age-window';
 export * from './column';
 export * from './unit-details';
-export * from './maps';
 export * from './age-model-overlay';
 export * from './correlation-chart';
 export * from './notes';
 export * from './facets';
+/** Legacy views */
+export * from '@macrostrat/map-views';

package/dist/index.js

@@ -1,29 +1,23 @@
 import { BasicUnitComponent, ColoredUnitComponent, EnvironmentColoredUnitComponent, SimpleUnitsColumn, UnitComponent, UnitsColumn, useUnitColor, useUnitColorByEnvironment } from "./units/index.js";
 import { AgeCursor, ApproximateHeightAxis, CompositeAgeAxis, CompositeAgeAxisCore, VerticalAxisLabel } from "./age-axis.js";
 import { prepareColumnUnits, usePreparedColumnUnits } from "./prepare-units/index.js";
+import { useAnimatedAgeWindow } from "./animated-age-window.js";
 import { Column, ColumnBasicInfo, ColumnContainer } from "./column.js";
 import { BoundaryAgeModelOverlay, ComputedSurfacesOverlay } from "./age-model-overlay.js";
 import { ColumnNotes } from "./notes.js";
+export * from "@macrostrat/map-views";
 import { AgeField, AgeLabel, AgeRange, Duration, IntervalProportions, getAge, getAgeRange } from "./unit-details/age-range.js";
 import { AnnotatedUnitsColumn, ColumnNotesProvider, CompositeUnitComponent, CompositeUnitsColumn, LabelTrackerProvider, SectionLabelsColumn, TrackedLabeledUnit } from "./units/composite.js";
-import { BaseColumnsLayer, SelectedColumnOverlay, buildColumnsStyle } from "./maps/layers/columns.js";
 import { BaseMeasurementsColumn, TruncatedList, groupNotesByPixelDistance, mergeHeightRanges, standardizeMeasurementHeight } from "./facets/measurements/base.js";
 import { ClickableText, Identifier, UnitIdentifier } from "@macrostrat/data-components";
-import { ColumnCenters, ColumnFeatures, ColumnKeyboardNavigation, Columns, CurrentColumn, MeasurementsLayer } from "./maps/column-navigation/svg/layers.js";
-import { ColumnCorrelationMap } from "./maps/column-correlation/core.js";
-import { ColumnCorrelationProvider, useColumnMapLink, useCorrelationMapStore } from "./maps/column-correlation/state.js";
-import { ColumnHoverInteraction, ColumnNavigationMap, ColumnSelectionManager, ColumnsNavigationLayer } from "./maps/column-navigation/mapbox/index.js";
 import { ColumnNavProvider, useColumnNav } from "./data-provider/column-nav.js";
-import { ColumnNavigationSVGMap, ResizableMapFrame } from "./maps/column-navigation/svg/index.js";
 import { CorrelationChart } from "./correlation-chart/main.js";
 import { DetritalColumn, DetritalGroup } from "./facets/detrital-zircon/index.js";
 import { FossilDataType, useFossilData } from "./facets/fossils/provider.js";
 import { HeightMethod, HybridScaleType } from "./prepare-units/types.js";
-import { InsetMap } from "./maps/inset-map/index.js";
 import { IsotopesColumn, IsotopesDataset } from "./facets/carbon-isotopes/isotopes-column.js";
 import { LegendPanelHeader, ReferencesField, ThicknessField, UnitDetailsFeature, UnitDetailsPanel } from "./unit-details/panel.js";
 import { LithologiesProvider, MacrostratColumnDataProvider, MacrostratColumnProvider, MacrostratColumnStateProvider, UnitSelectionProvider, columnUnitsAtom, columnUnitsMapAtom, scope, useColumnUnitsMap, useCompositeScale, useMacrostratColumnData, useMacrostratUnits } from "./data-provider/store.js";
-import { MacrostratUnitsOverlay, buildUnitsStyle } from "./maps/layers/units.js";
 import { MeasurementDataContext, MeasurementDataProvider, useMeasurementData } from "./facets/carbon-isotopes/data-provider.js";
 import { MergeSectionsMode, agesOverlap, createUnitSorter, ensureArray, ensureRealFloat, getPositionWithinUnit, getUnitHeightRange, unitsOverlap } from "./prepare-units/utils.js";
 import { PBDBFossilsColumn } from "./facets/fossils/index.js";
@@ -33,7 +27,6 @@ import { StratNameField } from "./unit-details/strat-names.js";
 import { UnitDetailsPanelWithNavigation } from "./unit-details/modal-panel.js";
 import { UnitDetailsPopover, UnitSelectionPopover } from "./unit-details/popover.js";
 import { UnitKeyboardNavigation, UnitSelectionCallbackManager, allowUnitSelectionAtom, selectedUnitElementAtom, selectedUnitIDAtom, useAtomOverlayPosition, useColumnRef, useSelectedUnit, useUnitSelection, useUnitSelectionDispatch, useUnitSelectionTarget } from "./data-provider/unit-selection.js";
-import { flattenLithologies, getMixedColorForData, getMixedUnitColor } from "./units/colors.js";
 import { parseLineFromString, stringifyLine } from "./correlation-chart/hash-string.js";
 import { preprocessUnits } from "./prepare-units/helpers.js";
 export {
@@ -43,7 +36,6 @@ export {
   AgeRange,
   AnnotatedUnitsColumn,
   ApproximateHeightAxis,
-  BaseColumnsLayer,
   BaseMeasurementsColumn,
   BasicUnitComponent,
   BoundaryAgeModelOverlay,
@@ -51,28 +43,16 @@ export {
   ColoredUnitComponent,
   Column,
   ColumnBasicInfo,
-  ColumnCenters,
   ColumnContainer,
-  ColumnCorrelationMap,
-  ColumnCorrelationProvider,
-  ColumnFeatures,
-  ColumnHoverInteraction,
-  ColumnKeyboardNavigation,
   ColumnNavProvider,
-  ColumnNavigationMap,
-  ColumnNavigationSVGMap,
   ColumnNotes,
   ColumnNotesProvider,
-  ColumnSelectionManager,
-  Columns,
-  ColumnsNavigationLayer,
   CompositeAgeAxis,
   CompositeAgeAxisCore,
   CompositeUnitComponent,
   CompositeUnitsColumn,
   ComputedSurfacesOverlay,
   CorrelationChart,
-  CurrentColumn,
   DetritalColumn,
   DetritalGroup,
   Duration,
@@ -81,7 +61,6 @@ export {
   HeightMethod,
   HybridScaleType,
   Identifier,
-  InsetMap,
   IntervalProportions,
   IsotopesColumn,
   IsotopesDataset,
@@ -91,18 +70,14 @@ export {
   MacrostratColumnDataProvider,
   MacrostratColumnProvider,
   MacrostratColumnStateProvider,
-  MacrostratUnitsOverlay,
   MeasurementDataContext,
   MeasurementDataProvider,
-  MeasurementsLayer,
   MergeSectionsMode,
   PBDBFossilsColumn,
   PBDBOccurrencesMatrix,
   ReferencesField,
-  ResizableMapFrame,
   SGPMeasurementsColumn,
   SectionLabelsColumn,
-  SelectedColumnOverlay,
   SimpleUnitsColumn,
   StratNameField,
   ThicknessField,
@@ -122,18 +97,13 @@ export {
   VerticalAxisLabel,
   agesOverlap,
   allowUnitSelectionAtom,
-  buildColumnsStyle,
-  buildUnitsStyle,
   columnUnitsAtom,
   columnUnitsMapAtom,
   createUnitSorter,
   ensureArray,
   ensureRealFloat,
-  flattenLithologies,
   getAge,
   getAgeRange,
-  getMixedColorForData,
-  getMixedUnitColor,
   getPositionWithinUnit,
   getUnitHeightRange,
   groupNotesByPixelDistance,
@@ -147,13 +117,12 @@ export {
   standardizeMeasurementHeight,
   stringifyLine,
   unitsOverlap,
+  useAnimatedAgeWindow,
   useAtomOverlayPosition,
-  useColumnMapLink,
   useColumnNav,
   useColumnRef,
   useColumnUnitsMap,
   useCompositeScale,
-  useCorrelationMapStore,
   useFossilData,
   useMacrostratColumnData,
   useMacrostratUnits,

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/prepare-units/composite-scale.cjs

@@ -9,10 +9,11 @@ function buildCompositeScaleInfo(inputScales, unconformityHeight) {
   let totalHeight = unconformityHeight / 2;
   let lastSectionTopHeight = 0;
   const packages2 = [];
-  for (const group of inputScales) {
+  for (let i = 0; i < inputScales.length; i++) {
+    const group = inputScales[i];
     const { domain, scale } = group;
     const [b_age, t_age] = domain;
-    const key = `package-${b_age}-${t_age}`;
+    const key = `package-${i}`;
     packages2.push({
       ...createPackageScale(group, totalHeight),
       key,
@@ -79,6 +80,7 @@ function buildSectionScale(data, opts) {
     minPixelScale = 0.2,
     axisType,
     minSectionHeight,
+    visibleWindow,
     scale,
     hybridScale
   } = opts;
@@ -97,7 +99,7 @@ function buildSectionScale(data, opts) {
   }
   if (scale == null) {
     if (_pixelScale == null) {
-      const avgAgeRange = findAverageUnitHeight(data, axisType);
+      const avgAgeRange = findAverageUnitHeight(data, axisType, visibleWindow);
       _pixelScale = Math.max(targetUnitHeight / avgAgeRange, minPixelScale);
     }
     let height = dAge * _pixelScale;
@@ -112,6 +114,78 @@ function buildSectionScale(data, opts) {
     0
   );
 }
+function resolveWindowScales(sections, focalWindow, floor) {
+  const [b_focal, t_focal] = focalWindow;
+  const scales = /* @__PURE__ */ new Map();
+  for (const section of sections) {
+    const t_age = Math.max(section.t_age, t_focal);
+    const b_age = Math.min(section.b_age, b_focal);
+    if (b_age <= t_age) continue;
+    const natural = section.scaleInfo.pixelScale;
+    if (!(natural > 0)) continue;
+    const isClipped = b_age < section.b_age || t_age > section.t_age;
+    const needed = isClipped && floor > 0 ? floor / (b_age - t_age) : 0;
+    scales.set(section, Math.max(natural, needed));
+  }
+  return scales;
+}
+function padWindowByPixels(sections, window, padding, scaleFor) {
+  if (!(padding > 0) || sections.length === 0) return window;
+  const [b_age, t_age] = window;
+  return [
+    spendOutward(sections, b_age, 1, padding, scaleFor),
+    spendOutward(sections, t_age, -1, padding, scaleFor)
+  ];
+}
+function spendOutward(sections, edge, direction, padding, scaleFor) {
+  const beyond = sections.filter(
+    (s) => direction * (s.b_age - edge) > 0 || direction * (s.t_age - edge) > 0
+  ).sort((a, b) => direction * (nearEdge(a, direction) - nearEdge(b, direction)));
+  let bound = edge;
+  let budget = padding;
+  for (const section of beyond) {
+    const pixelScale = scaleFor(section);
+    if (!(pixelScale > 0)) continue;
+    const from = direction > 0 ? Math.max(section.t_age, bound) : Math.min(section.b_age, bound);
+    const available = direction > 0 ? section.b_age - from : from - section.t_age;
+    if (available <= 0) continue;
+    const cost = available * pixelScale;
+    if (budget <= cost) return from + direction * (budget / pixelScale);
+    bound = direction > 0 ? section.b_age : section.t_age;
+    budget -= cost;
+  }
+  return bound;
+}
+function nearEdge(section, direction) {
+  return direction > 0 ? section.t_age : section.b_age;
+}
+function trimSectionsToWindow(sections, window, scaleFor) {
+  const [b_win, t_win] = window;
+  const out = [];
+  for (const section of sections) {
+    const t_age = Math.max(section.t_age, t_win);
+    const b_age = Math.min(section.b_age, b_win);
+    if (b_age <= t_age) continue;
+    const pixelScale = scaleFor(section);
+    if (b_age === section.b_age && t_age === section.t_age && pixelScale === section.scaleInfo.pixelScale) {
+      out.push(section);
+      continue;
+    }
+    out.push({
+      ...section,
+      t_age,
+      b_age,
+      units: section.units.filter((u) => utils.agesOverlap(u, { t_age, b_age })),
+      scaleInfo: createPackageScale({
+        domain: [b_age, t_age],
+        pixelScale,
+        pixelHeight: (b_age - t_age) * pixelScale,
+        scale: null
+      })
+    });
+  }
+  return out;
+}
 function createPackageScale(def, offset = 0) {
   const { domain, pixelScale, pixelHeight, scale, heightScale } = def;
   if (scale == null && pixelScale == null) {
@@ -159,12 +233,21 @@ function findSectionHeightRange(data, axisType) {
     return [b_pos, t_pos];
   }
 }
-function findAverageUnitHeight(data, axisType) {
-  const unitHeights = data.map((d) => {
+function findAverageUnitHeight(data, axisType, visibleWindow) {
+  const durations = (clip) => data.map((d) => {
     const [b_pos, t_pos] = utils.getUnitHeightRange(d, axisType);
-    return Math.abs(b_pos - t_pos);
-  });
-  return unitHeights.reduce((a, b) => a + b, 0) / unitHeights.length;
+    if (!clip) return Math.abs(b_pos - t_pos);
+    const [b_win, t_win] = visibleWindow;
+    return Math.max(
+      0,
+      Math.min(b_pos, b_win) - Math.max(t_pos, t_win)
+    );
+  }).filter((d) => d > 0);
+  const useWindow = visibleWindow != null && axisType === columnComponents.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;
 }
 function createCompositeScale(sections, interpolateUnconformities = false) {
   const scales = [];
@@ -280,4 +363,7 @@ exports.computeSectionHeights = computeSectionHeights;
 exports.createCompositeScale = createCompositeScale;
 exports.createPackageScale = createPackageScale;
 exports.finalizeSectionHeights = finalizeSectionHeights;
+exports.padWindowByPixels = padWindowByPixels;
+exports.resolveWindowScales = resolveWindowScales;
+exports.trimSectionsToWindow = trimSectionsToWindow;
 //# sourceMappingURL=composite-scale.cjs.map

package/dist/prepare-units/composite-scale.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"composite-scale.cjs","sources":["../../src/prepare-units/composite-scale.ts"],"sourcesContent":["import { ColumnAxisType } from \"@macrostrat/column-components\";\nimport { ensureArray, getUnitHeightRange } from \"./utils\";\nimport { ScaleContinuousNumeric, scaleLinear } from \"d3-scale\";\nimport { UnitLong } from \"@macrostrat/api-types\";\nimport { buildHybridScale } from \"./dynamic-scales\";\nimport { ExtUnit, HybridScaleType, SectionInfo } from \"./types\";\nimport type {\n  ColumnScaleOptions,\n  CompositeColumnData,\n  CompositeScaleData,\n  PackageLayoutData,\n  PackageScaleInfo,\n  PackageScaleLayoutData,\n  SectionScaleOptions,\n} from \"./types\";\n\n// Composite scale information augmented with units in each package\n\nexport function buildCompositeScaleInfo(\n  inputScales: PackageScaleInfo[],\n  unconformityHeight: number,\n): CompositeScaleData {\n  /** Finalize the heights of sections, including the heights of unconformities\n   * between them.\n   */\n\n  let totalHeight = unconformityHeight / 2;\n  let lastSectionTopHeight = 0;\n\n  const packages2: PackageScaleLayoutData[] = [];\n  for (const group of inputScales) {\n    const { domain, scale } = group;\n    const [b_age, t_age] = domain;\n    const key = `package-${b_age}-${t_age}`;\n\n    packages2.push({\n      ...createPackageScale(group, totalHeight),\n      key,\n      offset: totalHeight,\n      // Unconformity height above this particular section\n      paddingTop: totalHeight - lastSectionTopHeight,\n    });\n\n    const pixelHeight = Math.abs(scale(b_age) - scale(t_age));\n    lastSectionTopHeight = totalHeight + pixelHeight;\n    totalHeight = lastSectionTopHeight + unconformityHeight;\n  }\n  totalHeight += unconformityHeight / 2;\n  return {\n    totalHeight,\n    sections: packages2,\n  };\n}\n\nexport function finalizeSectionHeights<T extends UnitLong>(\n  sections: SectionInfoWithScale<T>[],\n  unconformityHeight: number,\n): CompositeColumnData<T> {\n  /** Finalize the heights of sections, including the heights of unconformities\n   * between them.\n   */\n\n  const sectionScales = sections.map((d) => d.scaleInfo);\n\n  const { totalHeight, sections: packages } = buildCompositeScaleInfo(\n    sectionScales,\n    unconformityHeight,\n  );\n\n  // This could perhaps be simplified.\n  const sections1: PackageLayoutData<T>[] = [];\n  for (const i in sections) {\n    const group = sections[i];\n    const scaleInfo = packages[i];\n    sections1.push({\n      ...group,\n      key: scaleInfo.key,\n      scaleInfo,\n    });\n  }\n  return {\n    totalHeight,\n    sections: sections1,\n  };\n}\n\nexport interface SectionInfoWithScale<\n  T extends UnitLong = ExtUnit,\n> extends SectionInfo<T> {\n  scaleInfo: PackageScaleInfo;\n}\n\nexport function computeSectionHeights<T extends UnitLong>(\n  sections: SectionInfo<T>[],\n  opts: ColumnScaleOptions,\n): SectionInfoWithScale<T>[] {\n  return sections.map((group) => {\n    return addScaleToSection<T>(group, opts);\n  });\n}\n\nfunction addScaleToSection<T extends UnitLong = ExtUnit>(\n  group: SectionInfo<T>,\n  opts: ColumnScaleOptions,\n): SectionInfoWithScale<T> {\n  const { t_age, b_age, t_pos, b_pos, units } = group;\n  let _range = null;\n  // if t_age and b_age are set for a group, use them to define the range...\n  if (opts.axisType == ColumnAxisType.AGE) {\n    _range = [b_age, t_age];\n  } else {\n    _range = [b_pos, t_pos];\n  }\n\n  const scaleInfo = buildSectionScale<T>(units, {\n    ...opts,\n    domain: _range,\n  });\n\n  return {\n    ...group,\n    scaleInfo,\n  };\n}\n\nfunction buildSectionScale<T extends UnitLong>(\n  data: T[],\n  opts: SectionScaleOptions,\n): PackageScaleInfo {\n  const {\n    targetUnitHeight = 20,\n    minPixelScale = 0.2,\n    axisType,\n    minSectionHeight,\n    scale,\n    hybridScale,\n  } = opts;\n  const domain = opts.domain ?? findSectionHeightRange(data, axisType);\n\n  const dAge = Math.abs(domain[0] - domain[1]);\n\n  let _pixelScale = opts.pixelScale;\n  let pixelHeight: number;\n\n  if (hybridScale != null) {\n    /** In an equidistant surfaces scale, we want to determine the heights of surfaces\n     * and then distribute units evenly between them.\n     * This is somewhat like an ordinal scale\n     */\n    if (hybridScale.type === HybridScaleType.EquidistantSurfaces) {\n      _pixelScale ??= targetUnitHeight;\n    }\n\n    return buildHybridScale(hybridScale, data, domain, {\n      pixelOffset: 0,\n      pixelScale: _pixelScale,\n    });\n  }\n\n  if (scale == null) {\n    if (_pixelScale == null) {\n      const avgAgeRange = findAverageUnitHeight(data, axisType);\n      // Get pixel height necessary to render average unit at target height\n      _pixelScale = Math.max(targetUnitHeight / avgAgeRange, minPixelScale);\n\n      // OLD METHOD that cares about overall section height vs. individual unit height\n      // 0.2 pixel per myr is the floor scale\n      //const targetHeight = targetUnitHeight * data.length;\n      // 1 pixel per myr is the floor scale\n      //_pixelScale = Math.max(targetHeight / dAge, minPixelScale);\n    }\n\n    let height = dAge * _pixelScale;\n    // If height is less than minSectionHeight, set it to minSectionHeight\n    const _minSectionHeight = minSectionHeight ?? targetUnitHeight ?? 0;\n    pixelHeight = Math.max(height, _minSectionHeight);\n    _pixelScale = pixelHeight / dAge;\n  } else {\n    // If a scale is provided, use it to compute pixel height\n    pixelHeight = Math.abs(scale(domain[0]) - scale(domain[1]));\n  }\n\n  return createPackageScale(\n    { scale, domain, pixelHeight, pixelScale: _pixelScale },\n    0,\n  );\n}\n\nexport function createPackageScale(\n  def: PackageScaleInfo,\n  offset: number = 0,\n): PackageScaleInfo {\n  /** Build a section scale */\n  // Domain should be oriented from bottom to top, but scale is oriented from top to bottom\n  const { domain, pixelScale, pixelHeight, scale, heightScale } = def;\n\n  if (scale == null && pixelScale == null) {\n    throw new Error(\"Either scale or pixelScale must be provided\");\n  }\n\n  let _scale: ScaleContinuousNumeric<number, number>;\n  if (scale == null) {\n    _scale = scaleLinear()\n      .domain([domain[1], domain[0]])\n      .range([offset, pixelHeight + offset]);\n  } else {\n    const domain0 = scale.domain();\n    const range0 = scale.range();\n    _scale = scale\n      .copy()\n      .domain(domain0)\n      .range(range0.map((d) => d + offset));\n  }\n\n  _scale.clamp();\n\n  let _heightScale = null;\n  if (heightScale != null) {\n    // Adjust height scale as well\n    const range0 = scale.range();\n    _heightScale = heightScale.copy().range(range0.map((d) => d + offset));\n    _heightScale.clamp();\n  }\n\n  return {\n    domain,\n    pixelScale,\n    pixelHeight,\n    scale: _scale,\n    // Internal details for hybrid scales. TODO: improve this\n    heightScale: _heightScale,\n  };\n}\n\nfunction findSectionHeightRange(\n  data: UnitLong[],\n  axisType: ColumnAxisType,\n): [number, number] {\n  if (axisType == null) {\n    throw new Error(\"Axis type is not set\");\n  }\n  if (axisType === ColumnAxisType.AGE) {\n    const t_age = Math.min(...data.map((d) => d.t_age));\n    const b_age = Math.max(...data.map((d) => d.b_age));\n    return [b_age, t_age];\n  } else if (\n    axisType == ColumnAxisType.DEPTH ||\n    axisType == ColumnAxisType.ORDINAL\n  ) {\n    const t_pos = Math.min(...data.map((d) => d.t_pos));\n    const b_pos = Math.max(...data.map((d) => d.b_pos));\n    return [b_pos, t_pos];\n  } else if (axisType == ColumnAxisType.HEIGHT) {\n    const t_pos = Math.max(...data.map((d) => d.t_pos));\n    const b_pos = Math.min(...data.map((d) => d.b_pos));\n    return [b_pos, t_pos];\n  }\n}\n\nfunction findAverageUnitHeight(\n  data: UnitLong[],\n  axisType: ColumnAxisType,\n): number {\n  const unitHeights = data.map((d) => {\n    const [b_pos, t_pos] = getUnitHeightRange(d, axisType);\n    return Math.abs(b_pos - t_pos);\n  });\n  return unitHeights.reduce((a, b) => a + b, 0) / unitHeights.length;\n}\n\nexport interface CompositeColumnScale {\n  (age: number): number | null;\n  copy(): CompositeColumnScale;\n  domain(): [number, number];\n  invert(pixelHeight: number): number | null;\n  clamp(clamp: boolean): void;\n}\n\nexport function createCompositeScale(\n  sections: PackageLayoutData[],\n  interpolateUnconformities: boolean = false,\n): CompositeColumnScale {\n  /** Create a scale that works across multiple packages */\n\n  const scales: ScaleContinuousNumeric<number, number>[] = [];\n\n  let lastScale: ScaleContinuousNumeric<number, number> | null = null;\n  for (const section of sections) {\n    const _scale = section.scaleInfo.scale.copy().clamp(true);\n    scales.push(_scale);\n    if (lastScale != null && interpolateUnconformities) {\n      // Add a new scale that interpolates between lastScale and _scale\n      const lastDomain = lastScale.domain();\n      const lastRange = lastScale.range();\n      const currentDomain = _scale.domain();\n      const currentRange = _scale.range();\n\n      const interpScale = scaleLinear()\n        .domain([lastDomain[lastDomain.length - 1], currentDomain[0]])\n        .range([lastRange[lastRange.length - 1], currentRange[0]])\n        .clamp(true);\n      scales.push(interpScale);\n    }\n    lastScale = _scale;\n  }\n\n  const scale: CompositeColumnScale = (age) => {\n    for (const s of scales) {\n      const domain = s.domain();\n      if (\n        domain[0] < domain[domain.length - 1] &&\n        age >= domain[0] &&\n        age <= domain[domain.length - 1]\n      ) {\n        // Age axes\n        return s(age);\n      } else if (age <= domain[0] && age >= domain[domain.length - 1]) {\n        // Normal axes like height\n        return s(age);\n      }\n    }\n    return null;\n  };\n\n  scale.copy = () => {\n    return createCompositeScale(sections, interpolateUnconformities);\n  };\n\n  scale.domain = () => {\n    /** Return the domain of the scale */\n    const vals = sections.flatMap((d) => d.scaleInfo.domain);\n    if (vals[0] < vals[vals.length - 1]) {\n      // age axes\n      return [Math.min(...vals), Math.max(...vals)];\n    }\n    // Normal axes like height\n    return [Math.max(...vals), Math.min(...vals)];\n  };\n\n  scale.invert = (pixelHeight) => {\n    /** Invert the scale to get the age at a given pixel height */\n    // Iterate through the sections to find the correct one\n    for (const scale of scales) {\n      const range = scale.range();\n      if (\n        pixelHeight > Math.min(...range) &&\n        pixelHeight <= Math.max(...range)\n      ) {\n        //console.log(\"Inverting scale at pixel height\", pixelHeight);\n        return scale.invert(pixelHeight);\n      }\n    }\n    return null;\n  };\n\n  scale.clamp = (clamp: boolean) => {\n    /** Clamp all constituent scales */\n    for (const s of scales) {\n      s.clamp(clamp);\n    }\n  };\n\n  return scale;\n}\n\n/** Collapse sections separated by unconformities that are smaller than a given pixel height. */\nexport function collapseUnconformitiesByPixelHeight<T extends UnitLong>(\n  sections: SectionInfoWithScale<T>[],\n  threshold: number,\n  opts: ColumnScaleOptions,\n): SectionInfoWithScale<T>[] {\n  const newSections = [];\n  let currentSection: SectionInfoWithScale<T> | null = null;\n  for (const nextSection of sections) {\n    if (currentSection == null) {\n      currentSection = nextSection;\n      continue;\n    }\n    let heights: [number, number];\n    let pxHeights: [number, number];\n    if (opts.axisType !== ColumnAxisType.AGE) {\n      heights = [nextSection.t_pos, currentSection.b_pos];\n    } else {\n      heights = [nextSection.t_age, currentSection.b_age];\n    }\n\n    const _diff = (vals: number[]) => {\n      return Math.abs(vals[0] - vals[1]);\n    };\n\n    pxHeights = [\n      _diff(heights.map(nextSection.scaleInfo.scale)),\n      _diff(heights.map(currentSection.scaleInfo.scale)),\n    ];\n\n    const pxHeight = Math.min(...pxHeights);\n\n    if (pxHeight < threshold) {\n      let t_pos: number;\n      let b_pos: number;\n      if (\n        opts.axisType == ColumnAxisType.AGE ||\n        opts.axisType == ColumnAxisType.DEPTH\n      ) {\n        t_pos = Math.min(currentSection.t_pos, nextSection.t_pos);\n        b_pos = Math.max(currentSection.b_pos, nextSection.b_pos);\n      } else {\n        t_pos = Math.max(currentSection.t_pos, nextSection.t_pos);\n        b_pos = Math.min(currentSection.b_pos, nextSection.b_pos);\n      }\n\n      // We need to merge the sections\n      const compositeSection0: SectionInfo<T> = {\n        units: [...currentSection.units, ...nextSection.units],\n        section_id: [\n          ...ensureArray(currentSection.section_id),\n          ...ensureArray(nextSection.section_id),\n        ],\n        t_age: Math.min(currentSection.t_age, nextSection.t_age),\n        b_age: Math.max(currentSection.b_age, nextSection.b_age),\n        t_pos,\n        b_pos,\n      };\n\n      currentSection = addScaleToSection(compositeSection0, opts);\n    } else {\n      // We need to keep the section\n      newSections.push(currentSection);\n      currentSection = nextSection;\n    }\n  }\n  if (currentSection != null) {\n    newSections.push(currentSection);\n  }\n\n  return newSections;\n}\n"],"names":["ColumnAxisType","HybridScaleType","buildHybridScale","scaleLinear","getUnitHeightRange","scale","ensureArray"],"mappings":"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"}
+{"version":3,"file":"composite-scale.cjs","sources":["../../src/prepare-units/composite-scale.ts"],"sourcesContent":["import { ColumnAxisType } from \"@macrostrat/column-components\";\nimport { agesOverlap, ensureArray, getUnitHeightRange } from \"./utils\";\nimport { ScaleContinuousNumeric, scaleLinear } from \"d3-scale\";\nimport { UnitLong } from \"@macrostrat/api-types\";\nimport { buildHybridScale } from \"./dynamic-scales\";\nimport { ExtUnit, HybridScaleType, SectionInfo } from \"./types\";\nimport type {\n  ColumnScaleOptions,\n  CompositeColumnData,\n  CompositeScaleData,\n  PackageLayoutData,\n  PackageScaleInfo,\n  PackageScaleLayoutData,\n  SectionScaleOptions,\n} from \"./types\";\n\n// Composite scale information augmented with units in each package\n\nexport function buildCompositeScaleInfo(\n  inputScales: PackageScaleInfo[],\n  unconformityHeight: number,\n): CompositeScaleData {\n  /** Finalize the heights of sections, including the heights of unconformities\n   * between them.\n   */\n\n  let totalHeight = unconformityHeight / 2;\n  let lastSectionTopHeight = 0;\n\n  const packages2: PackageScaleLayoutData[] = [];\n  for (let i = 0; i < inputScales.length; i++) {\n    const group = inputScales[i];\n    const { domain, scale } = group;\n    const [b_age, t_age] = domain;\n    // Positionally stable key: packages are always emitted in age order, so the\n    // index is a stable identity. An age-based key (`package-${b_age}-${t_age}`)\n    // changes every frame while the age window animates, forcing every package,\n    // column, and timescale slice in the correlation chart to remount each frame.\n    const key = `package-${i}`;\n\n    packages2.push({\n      ...createPackageScale(group, totalHeight),\n      key,\n      offset: totalHeight,\n      // Unconformity height above this particular section\n      paddingTop: totalHeight - lastSectionTopHeight,\n    });\n\n    const pixelHeight = Math.abs(scale(b_age) - scale(t_age));\n    lastSectionTopHeight = totalHeight + pixelHeight;\n    totalHeight = lastSectionTopHeight + unconformityHeight;\n  }\n  totalHeight += unconformityHeight / 2;\n  return {\n    totalHeight,\n    sections: packages2,\n  };\n}\n\nexport function finalizeSectionHeights<T extends UnitLong>(\n  sections: SectionInfoWithScale<T>[],\n  unconformityHeight: number,\n): CompositeColumnData<T> {\n  /** Finalize the heights of sections, including the heights of unconformities\n   * between them.\n   */\n\n  const sectionScales = sections.map((d) => d.scaleInfo);\n\n  const { totalHeight, sections: packages } = buildCompositeScaleInfo(\n    sectionScales,\n    unconformityHeight,\n  );\n\n  // This could perhaps be simplified.\n  const sections1: PackageLayoutData<T>[] = [];\n  for (const i in sections) {\n    const group = sections[i];\n    const scaleInfo = packages[i];\n    sections1.push({\n      ...group,\n      key: scaleInfo.key,\n      scaleInfo,\n    });\n  }\n  return {\n    totalHeight,\n    sections: sections1,\n  };\n}\n\nexport interface SectionInfoWithScale<\n  T extends UnitLong = ExtUnit,\n> extends SectionInfo<T> {\n  scaleInfo: PackageScaleInfo;\n}\n\nexport function computeSectionHeights<T extends UnitLong>(\n  sections: SectionInfo<T>[],\n  opts: ColumnScaleOptions,\n): SectionInfoWithScale<T>[] {\n  return sections.map((group) => {\n    return addScaleToSection<T>(group, opts);\n  });\n}\n\nfunction addScaleToSection<T extends UnitLong = ExtUnit>(\n  group: SectionInfo<T>,\n  opts: ColumnScaleOptions,\n): SectionInfoWithScale<T> {\n  const { t_age, b_age, t_pos, b_pos, units } = group;\n  let _range = null;\n  // if t_age and b_age are set for a group, use them to define the range...\n  if (opts.axisType == ColumnAxisType.AGE) {\n    _range = [b_age, t_age];\n  } else {\n    _range = [b_pos, t_pos];\n  }\n\n  const scaleInfo = buildSectionScale<T>(units, {\n    ...opts,\n    domain: _range,\n  });\n\n  return {\n    ...group,\n    scaleInfo,\n  };\n}\n\nfunction buildSectionScale<T extends UnitLong>(\n  data: T[],\n  opts: SectionScaleOptions,\n): PackageScaleInfo {\n  const {\n    targetUnitHeight = 20,\n    minPixelScale = 0.2,\n    axisType,\n    minSectionHeight,\n    visibleWindow,\n    scale,\n    hybridScale,\n  } = opts;\n  const domain = opts.domain ?? findSectionHeightRange(data, axisType);\n\n  const dAge = Math.abs(domain[0] - domain[1]);\n\n  let _pixelScale = opts.pixelScale;\n  let pixelHeight: number;\n\n  if (hybridScale != null) {\n    /** In an equidistant surfaces scale, we want to determine the heights of surfaces\n     * and then distribute units evenly between them.\n     * This is somewhat like an ordinal scale\n     */\n    if (hybridScale.type === HybridScaleType.EquidistantSurfaces) {\n      _pixelScale ??= targetUnitHeight;\n    }\n\n    return buildHybridScale(hybridScale, data, domain, {\n      pixelOffset: 0,\n      pixelScale: _pixelScale,\n    });\n  }\n\n  if (scale == null) {\n    if (_pixelScale == null) {\n      const avgAgeRange = findAverageUnitHeight(data, axisType, visibleWindow);\n      // Get pixel height necessary to render average unit at target height\n      _pixelScale = Math.max(targetUnitHeight / avgAgeRange, minPixelScale);\n\n      // OLD METHOD that cares about overall section height vs. individual unit height\n      // 0.2 pixel per myr is the floor scale\n      //const targetHeight = targetUnitHeight * data.length;\n      // 1 pixel per myr is the floor scale\n      //_pixelScale = Math.max(targetHeight / dAge, minPixelScale);\n    }\n\n    let height = dAge * _pixelScale;\n    // If height is less than minSectionHeight, set it to minSectionHeight.\n    // Sections reach here at their *full* extent (the rendered window is applied\n    // afterwards, by `trimSectionsToWindow`), so this floor only ever inflates a\n    // genuinely small section — which is what it's for — and never a sliver that\n    // the window happens to cut.\n    const _minSectionHeight = minSectionHeight ?? targetUnitHeight ?? 0;\n    pixelHeight = Math.max(height, _minSectionHeight);\n    _pixelScale = pixelHeight / dAge;\n  } else {\n    // If a scale is provided, use it to compute pixel height\n    pixelHeight = Math.abs(scale(domain[0]) - scale(domain[1]));\n  }\n\n  return createPackageScale(\n    { scale, domain, pixelHeight, pixelScale: _pixelScale },\n    0,\n  );\n}\n\n/**\n * The density each section will actually render at once the window is applied.\n *\n * A section the window cuts short is still being *looked at*, so\n * `minSectionHeight` applies to what remains — it's honored by expanding the\n * section's scale, not by showing more of it. Resolving this **before** padding\n * matters: padding is a pixel margin measured at the density it will render at,\n * and a section stretched to the floor afterwards would multiply the margin\n * along with everything else (a 20 px margin in a band stretched 4× renders at\n * 80 px, and asymmetrically so whenever one side is truncated).\n *\n * Sections the window leaves whole keep their laid-out density — they already\n * met the floor when they were sized.\n */\nexport function resolveWindowScales<T extends UnitLong>(\n  sections: SectionInfoWithScale<T>[],\n  focalWindow: [number, number],\n  floor: number,\n): Map<SectionInfoWithScale<T>, number> {\n  const [b_focal, t_focal] = focalWindow;\n  const scales = new Map<SectionInfoWithScale<T>, number>();\n\n  for (const section of sections) {\n    const t_age = Math.max(section.t_age, t_focal);\n    const b_age = Math.min(section.b_age, b_focal);\n    // Sections outside the focal window are visible only as padding; they keep\n    // their own density and render exactly the pixels asked for.\n    if (b_age <= t_age) continue;\n\n    const natural = section.scaleInfo.pixelScale;\n    if (!(natural > 0)) continue;\n\n    const isClipped = b_age < section.b_age || t_age > section.t_age;\n    const needed = isClipped && floor > 0 ? floor / (b_age - t_age) : 0;\n    scales.set(section, Math.max(natural, needed));\n  }\n  return scales;\n}\n\n/**\n * Expand an age window outward by `padding` **pixels** of column, spending the\n * budget against sections that are already laid out at full extent, at the\n * densities they will finally render at (`scaleFor`).\n *\n * Because the layout is done, this is exact rather than predicted: each section\n * contributes its own real pixel height. Padding collapses when the column runs\n * out on that side.\n *\n * Unconformities between sections cost nothing. They render at a fixed height\n * that's typically larger than the padding itself (30–60 px), so charging them\n * would mean padding could never reach across a gap — which is the case it\n * exists for: revealing the neighboring section keeps its timescale intervals\n * navigable. The padding is a budget of neighboring *content*.\n */\nexport function padWindowByPixels<T extends UnitLong>(\n  sections: SectionInfoWithScale<T>[],\n  window: [number, number],\n  padding: number,\n  scaleFor: (section: SectionInfoWithScale<T>) => number,\n): [number, number] {\n  if (!(padding > 0) || sections.length === 0) return window;\n  const [b_age, t_age] = window;\n  return [\n    spendOutward(sections, b_age, 1, padding, scaleFor),\n    spendOutward(sections, t_age, -1, padding, scaleFor),\n  ];\n}\n\n/** Walk out from one edge of the window through laid-out sections, spending a\n * pixel budget, and return the age it lands on. `direction` is +1 toward older\n * ages, -1 toward younger. */\nfunction spendOutward<T extends UnitLong>(\n  sections: SectionInfoWithScale<T>[],\n  edge: number,\n  direction: 1 | -1,\n  padding: number,\n  scaleFor: (section: SectionInfoWithScale<T>) => number,\n): number {\n  // Sections ordered outward from the edge, keeping only what lies beyond it.\n  const beyond = sections\n    .filter(\n      (s) => direction * (s.b_age - edge) > 0 || direction * (s.t_age - edge) > 0,\n    )\n    .sort((a, b) => direction * (nearEdge(a, direction) - nearEdge(b, direction)));\n\n  let bound = edge;\n  let budget = padding;\n\n  for (const section of beyond) {\n    const pixelScale = scaleFor(section);\n    if (!(pixelScale > 0)) continue;\n\n    const from =\n      direction > 0\n        ? Math.max(section.t_age, bound)\n        : Math.min(section.b_age, bound);\n    const available = direction > 0 ? section.b_age - from : from - section.t_age;\n    if (available <= 0) continue;\n\n    const cost = available * pixelScale;\n    if (budget <= cost) return from + direction * (budget / pixelScale);\n\n    bound = direction > 0 ? section.b_age : section.t_age;\n    budget -= cost;\n  }\n  return bound;\n}\n\n/** The age at which a section starts, measured from the window edge outward. */\nfunction nearEdge<T extends UnitLong>(\n  section: SectionInfoWithScale<T>,\n  direction: 1 | -1,\n): number {\n  return direction > 0 ? section.t_age : section.b_age;\n}\n\n/**\n * Clip laid-out sections to the rendered window — the last step of layout, so\n * that every section has already been sized (and floored) at its full extent.\n * Each section renders at the density `scaleFor` resolved for it, which is what\n * keeps a padding margin the same number of pixels as the band it borders is\n * stretched to meet `minSectionHeight`.\n */\nexport function trimSectionsToWindow<T extends UnitLong>(\n  sections: SectionInfoWithScale<T>[],\n  window: [number, number],\n  scaleFor: (section: SectionInfoWithScale<T>) => number,\n): SectionInfoWithScale<T>[] {\n  const [b_win, t_win] = window;\n  const out: SectionInfoWithScale<T>[] = [];\n\n  for (const section of sections) {\n    const t_age = Math.max(section.t_age, t_win);\n    const b_age = Math.min(section.b_age, b_win);\n    if (b_age <= t_age) continue;\n\n    const pixelScale = scaleFor(section);\n    if (\n      b_age === section.b_age &&\n      t_age === section.t_age &&\n      pixelScale === section.scaleInfo.pixelScale\n    ) {\n      out.push(section);\n      continue;\n    }\n\n    out.push({\n      ...section,\n      t_age,\n      b_age,\n      units: section.units.filter((u) => agesOverlap(u, { t_age, b_age })),\n      scaleInfo: createPackageScale({\n        domain: [b_age, t_age],\n        pixelScale,\n        pixelHeight: (b_age - t_age) * pixelScale,\n        scale: null,\n      }),\n    });\n  }\n  return out;\n}\n\nexport function createPackageScale(\n  def: PackageScaleInfo,\n  offset: number = 0,\n): PackageScaleInfo {\n  /** Build a section scale */\n  // Domain should be oriented from bottom to top, but scale is oriented from top to bottom\n  const { domain, pixelScale, pixelHeight, scale, heightScale } = def;\n\n  if (scale == null && pixelScale == null) {\n    throw new Error(\"Either scale or pixelScale must be provided\");\n  }\n\n  let _scale: ScaleContinuousNumeric<number, number>;\n  if (scale == null) {\n    _scale = scaleLinear()\n      .domain([domain[1], domain[0]])\n      .range([offset, pixelHeight + offset]);\n  } else {\n    const domain0 = scale.domain();\n    const range0 = scale.range();\n    _scale = scale\n      .copy()\n      .domain(domain0)\n      .range(range0.map((d) => d + offset));\n  }\n\n  _scale.clamp();\n\n  let _heightScale = null;\n  if (heightScale != null) {\n    // Adjust height scale as well\n    const range0 = scale.range();\n    _heightScale = heightScale.copy().range(range0.map((d) => d + offset));\n    _heightScale.clamp();\n  }\n\n  return {\n    domain,\n    pixelScale,\n    pixelHeight,\n    scale: _scale,\n    // Internal details for hybrid scales. TODO: improve this\n    heightScale: _heightScale,\n  };\n}\n\nfunction findSectionHeightRange(\n  data: UnitLong[],\n  axisType: ColumnAxisType,\n): [number, number] {\n  if (axisType == null) {\n    throw new Error(\"Axis type is not set\");\n  }\n  if (axisType === ColumnAxisType.AGE) {\n    const t_age = Math.min(...data.map((d) => d.t_age));\n    const b_age = Math.max(...data.map((d) => d.b_age));\n    return [b_age, t_age];\n  } else if (\n    axisType == ColumnAxisType.DEPTH ||\n    axisType == ColumnAxisType.ORDINAL\n  ) {\n    const t_pos = Math.min(...data.map((d) => d.t_pos));\n    const b_pos = Math.max(...data.map((d) => d.b_pos));\n    return [b_pos, t_pos];\n  } else if (axisType == ColumnAxisType.HEIGHT) {\n    const t_pos = Math.max(...data.map((d) => d.t_pos));\n    const b_pos = Math.min(...data.map((d) => d.b_pos));\n    return [b_pos, t_pos];\n  }\n}\n\nfunction findAverageUnitHeight(\n  data: UnitLong[],\n  axisType: ColumnAxisType,\n  visibleWindow?: [number, number] | null,\n): number {\n  /** The typical duration of a unit, which `targetUnitHeight` sizes.\n   *\n   * Measured over what the render window actually *shows* — units outside it\n   * are ignored and a unit it cuts through counts only for its visible part.\n   * That's what makes `targetUnitHeight` mean the same thing at every zoom\n   * depth: the units on screen are drawn at the target height whether they're\n   * whole or slivers of something much longer.\n   *\n   * A section the window doesn't reach has nothing visible to measure, so it\n   * falls back to its own units at full duration — it's drawn at its own scale.\n   * (Deriving it from the padded window instead would be circular: padding is\n   * measured in pixels, which is what we're trying to establish.)\n   */\n  const durations = (clip: boolean) =>\n    data\n      .map((d) => {\n        const [b_pos, t_pos] = getUnitHeightRange(d, axisType);\n        if (!clip) return Math.abs(b_pos - t_pos);\n        const [b_win, t_win] = visibleWindow;\n        return Math.max(\n          0,\n          Math.min(b_pos, b_win) - Math.max(t_pos, t_win),\n        );\n      })\n      .filter((d) => d > 0);\n\n  const useWindow = visibleWindow != null && axisType === ColumnAxisType.AGE;\n  let heights = useWindow ? durations(true) : [];\n  if (heights.length === 0) heights = durations(false);\n  if (heights.length === 0) return 1;\n\n  return heights.reduce((a, b) => a + b, 0) / heights.length;\n}\n\nexport interface CompositeColumnScale {\n  (age: number): number | null;\n  copy(): CompositeColumnScale;\n  domain(): [number, number];\n  invert(pixelHeight: number): number | null;\n  clamp(clamp: boolean): void;\n}\n\nexport function createCompositeScale(\n  sections: PackageLayoutData[],\n  interpolateUnconformities: boolean = false,\n): CompositeColumnScale {\n  /** Create a scale that works across multiple packages */\n\n  const scales: ScaleContinuousNumeric<number, number>[] = [];\n\n  let lastScale: ScaleContinuousNumeric<number, number> | null = null;\n  for (const section of sections) {\n    const _scale = section.scaleInfo.scale.copy().clamp(true);\n    scales.push(_scale);\n    if (lastScale != null && interpolateUnconformities) {\n      // Add a new scale that interpolates between lastScale and _scale\n      const lastDomain = lastScale.domain();\n      const lastRange = lastScale.range();\n      const currentDomain = _scale.domain();\n      const currentRange = _scale.range();\n\n      const interpScale = scaleLinear()\n        .domain([lastDomain[lastDomain.length - 1], currentDomain[0]])\n        .range([lastRange[lastRange.length - 1], currentRange[0]])\n        .clamp(true);\n      scales.push(interpScale);\n    }\n    lastScale = _scale;\n  }\n\n  const scale: CompositeColumnScale = (age) => {\n    for (const s of scales) {\n      const domain = s.domain();\n      if (\n        domain[0] < domain[domain.length - 1] &&\n        age >= domain[0] &&\n        age <= domain[domain.length - 1]\n      ) {\n        // Age axes\n        return s(age);\n      } else if (age <= domain[0] && age >= domain[domain.length - 1]) {\n        // Normal axes like height\n        return s(age);\n      }\n    }\n    return null;\n  };\n\n  scale.copy = () => {\n    return createCompositeScale(sections, interpolateUnconformities);\n  };\n\n  scale.domain = () => {\n    /** Return the domain of the scale */\n    const vals = sections.flatMap((d) => d.scaleInfo.domain);\n    if (vals[0] < vals[vals.length - 1]) {\n      // age axes\n      return [Math.min(...vals), Math.max(...vals)];\n    }\n    // Normal axes like height\n    return [Math.max(...vals), Math.min(...vals)];\n  };\n\n  scale.invert = (pixelHeight) => {\n    /** Invert the scale to get the age at a given pixel height */\n    // Iterate through the sections to find the correct one\n    for (const scale of scales) {\n      const range = scale.range();\n      if (\n        pixelHeight > Math.min(...range) &&\n        pixelHeight <= Math.max(...range)\n      ) {\n        //console.log(\"Inverting scale at pixel height\", pixelHeight);\n        return scale.invert(pixelHeight);\n      }\n    }\n    return null;\n  };\n\n  scale.clamp = (clamp: boolean) => {\n    /** Clamp all constituent scales */\n    for (const s of scales) {\n      s.clamp(clamp);\n    }\n  };\n\n  return scale;\n}\n\n/** Collapse sections separated by unconformities that are smaller than a given pixel height. */\nexport function collapseUnconformitiesByPixelHeight<T extends UnitLong>(\n  sections: SectionInfoWithScale<T>[],\n  threshold: number,\n  opts: ColumnScaleOptions,\n): SectionInfoWithScale<T>[] {\n  const newSections = [];\n  let currentSection: SectionInfoWithScale<T> | null = null;\n  for (const nextSection of sections) {\n    if (currentSection == null) {\n      currentSection = nextSection;\n      continue;\n    }\n    let heights: [number, number];\n    let pxHeights: [number, number];\n    if (opts.axisType !== ColumnAxisType.AGE) {\n      heights = [nextSection.t_pos, currentSection.b_pos];\n    } else {\n      heights = [nextSection.t_age, currentSection.b_age];\n    }\n\n    const _diff = (vals: number[]) => {\n      return Math.abs(vals[0] - vals[1]);\n    };\n\n    pxHeights = [\n      _diff(heights.map(nextSection.scaleInfo.scale)),\n      _diff(heights.map(currentSection.scaleInfo.scale)),\n    ];\n\n    const pxHeight = Math.min(...pxHeights);\n\n    if (pxHeight < threshold) {\n      let t_pos: number;\n      let b_pos: number;\n      if (\n        opts.axisType == ColumnAxisType.AGE ||\n        opts.axisType == ColumnAxisType.DEPTH\n      ) {\n        t_pos = Math.min(currentSection.t_pos, nextSection.t_pos);\n        b_pos = Math.max(currentSection.b_pos, nextSection.b_pos);\n      } else {\n        t_pos = Math.max(currentSection.t_pos, nextSection.t_pos);\n        b_pos = Math.min(currentSection.b_pos, nextSection.b_pos);\n      }\n\n      // We need to merge the sections\n      const compositeSection0: SectionInfo<T> = {\n        units: [...currentSection.units, ...nextSection.units],\n        section_id: [\n          ...ensureArray(currentSection.section_id),\n          ...ensureArray(nextSection.section_id),\n        ],\n        t_age: Math.min(currentSection.t_age, nextSection.t_age),\n        b_age: Math.max(currentSection.b_age, nextSection.b_age),\n        t_pos,\n        b_pos,\n      };\n\n      currentSection = addScaleToSection(compositeSection0, opts);\n    } else {\n      // We need to keep the section\n      newSections.push(currentSection);\n      currentSection = nextSection;\n    }\n  }\n  if (currentSection != null) {\n    newSections.push(currentSection);\n  }\n\n  return newSections;\n}\n"],"names":["ColumnAxisType","HybridScaleType","buildHybridScale","agesOverlap","scaleLinear","getUnitHeightRange","scale","ensureArray"],"mappings":"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"}

package/dist/prepare-units/composite-scale.d.ts

@@ -6,6 +6,45 @@ export interface SectionInfoWithScale<T extends UnitLong = ExtUnit> extends Sect
     scaleInfo: PackageScaleInfo;
 }
 export declare function computeSectionHeights<T extends UnitLong>(sections: SectionInfo<T>[], opts: ColumnScaleOptions): SectionInfoWithScale<T>[];
+/**
+ * The density each section will actually render at once the window is applied.
+ *
+ * A section the window cuts short is still being *looked at*, so
+ * `minSectionHeight` applies to what remains — it's honored by expanding the
+ * section's scale, not by showing more of it. Resolving this **before** padding
+ * matters: padding is a pixel margin measured at the density it will render at,
+ * and a section stretched to the floor afterwards would multiply the margin
+ * along with everything else (a 20 px margin in a band stretched 4× renders at
+ * 80 px, and asymmetrically so whenever one side is truncated).
+ *
+ * Sections the window leaves whole keep their laid-out density — they already
+ * met the floor when they were sized.
+ */
+export declare function resolveWindowScales<T extends UnitLong>(sections: SectionInfoWithScale<T>[], focalWindow: [number, number], floor: number): Map<SectionInfoWithScale<T>, number>;
+/**
+ * Expand an age window outward by `padding` **pixels** of column, spending the
+ * budget against sections that are already laid out at full extent, at the
+ * densities they will finally render at (`scaleFor`).
+ *
+ * Because the layout is done, this is exact rather than predicted: each section
+ * contributes its own real pixel height. Padding collapses when the column runs
+ * out on that side.
+ *
+ * Unconformities between sections cost nothing. They render at a fixed height
+ * that's typically larger than the padding itself (30–60 px), so charging them
+ * would mean padding could never reach across a gap — which is the case it
+ * exists for: revealing the neighboring section keeps its timescale intervals
+ * navigable. The padding is a budget of neighboring *content*.
+ */
+export declare function padWindowByPixels<T extends UnitLong>(sections: SectionInfoWithScale<T>[], window: [number, number], padding: number, scaleFor: (section: SectionInfoWithScale<T>) => number): [number, number];
+/**
+ * Clip laid-out sections to the rendered window — the last step of layout, so
+ * that every section has already been sized (and floored) at its full extent.
+ * Each section renders at the density `scaleFor` resolved for it, which is what
+ * keeps a padding margin the same number of pixels as the band it borders is
+ * stretched to meet `minSectionHeight`.
+ */
+export declare function trimSectionsToWindow<T extends UnitLong>(sections: SectionInfoWithScale<T>[], window: [number, number], scaleFor: (section: SectionInfoWithScale<T>) => number): SectionInfoWithScale<T>[];
 export declare function createPackageScale(def: PackageScaleInfo, offset?: number): PackageScaleInfo;
 export interface CompositeColumnScale {
     (age: number): number | null;