@macrostrat/column-views 2.4.4 → 3.0.0

package/dist/prepare-units/index.js

@@ -0,0 +1,131 @@
+import { preprocessSectionUnit, getSectionPosRange, getSectionAgeRange, groupUnitsIntoSectionsBySectionID, groupUnitsIntoSectionsByOverlap, mergeOverlappingSections, preprocessUnits } from "./helpers.js";
+import { ColumnAxisType } from "@macrostrat/column-components";
+import { useMemo } from "react";
+import { computeSectionHeights, collapseUnconformitiesByPixelHeight, finalizeSectionHeights } from "./composite-scale.js";
+import { MergeSectionsMode, agesOverlap, unitsOverlap } from "./utils.js";
+import { createUnitSorter, ensureArray, ensureRealFloat, getPositionWithinUnit, getUnitHeightRange } from "./utils.js";
+function usePreparedColumnUnits(data, options) {
+  return useMemo(() => {
+    return prepareColumnUnits(data, options);
+  }, [data, ...Object.values(options)]);
+}
+function prepareColumnUnits(units, options) {
+  let { t_age, b_age, t_pos, b_pos } = options;
+  const {
+    mergeSections = MergeSectionsMode.OVERLAPPING,
+    axisType,
+    unconformityHeight,
+    collapseSmallUnconformities = false,
+    hybridScale,
+    scale
+  } = options;
+  let _totalHeight = null;
+  if (scale != null) {
+    const domain = scale.domain();
+    if (axisType == ColumnAxisType.AGE) {
+      if (t_age == null) t_age = Math.min(...domain);
+      if (b_age == null) b_age = Math.max(...domain);
+      _totalHeight = Math.abs(scale(b_age) - scale(t_age));
+    } else {
+      if (t_pos == null) t_pos = Math.min(...domain);
+      if (b_pos == null) b_pos = Math.max(...domain);
+      _totalHeight = Math.abs(scale(b_pos) - scale(t_pos));
+    }
+  }
+  let units1 = units.map(preprocessSectionUnit);
+  units1 = units1.filter((d) => {
+    if (axisType == ColumnAxisType.AGE) {
+      return agesOverlap(d, { t_age, b_age });
+    } else {
+      return unitsOverlap(d, { t_pos, b_pos }, axisType);
+    }
+  });
+  let mergeMode = mergeSections;
+  let sections0;
+  if (mergeMode == MergeSectionsMode.ALL) {
+    const [b_unit_pos, t_unit_pos] = getSectionPosRange(units1, axisType);
+    const [b_unit_age, t_unit_age] = getSectionAgeRange(units1);
+    sections0 = [
+      {
+        section_id: 0,
+        /**
+         * If ages limits are directly specified, use them to define the section bounds.
+         * */
+        t_pos: t_unit_pos,
+        b_pos: b_unit_pos,
+        t_age: t_unit_age,
+        b_age: b_unit_age,
+        units: units1
+      }
+    ];
+  } else if (axisType == ColumnAxisType.AGE) {
+    sections0 = groupUnitsIntoSectionsBySectionID(units1, axisType);
+  } else {
+    sections0 = groupUnitsIntoSectionsByOverlap(units1, axisType);
+  }
+  for (let section of sections0) {
+    if (axisType == ColumnAxisType.AGE) {
+      section.t_age = Math.max(section.t_age, t_age ?? -Infinity);
+      section.b_age = Math.min(section.b_age, b_age ?? Infinity);
+    } else if (axisType == ColumnAxisType.DEPTH) {
+      section.t_pos = Math.max(section.t_pos, t_pos ?? -Infinity);
+      section.b_pos = Math.min(section.b_pos, b_pos ?? Infinity);
+    } else if (axisType == ColumnAxisType.HEIGHT) {
+      section.t_pos = Math.max(section.t_pos, t_pos ?? -Infinity);
+      section.b_pos = Math.min(section.b_pos, b_pos ?? Infinity);
+    }
+  }
+  let sections = sections0;
+  if (mergeSections == MergeSectionsMode.OVERLAPPING && axisType == ColumnAxisType.AGE) {
+    sections = mergeOverlappingSections(sections);
+  }
+  sections = sections.filter((d) => d != null);
+  let sectionsWithScales = computeSectionHeights(sections, options);
+  if (collapseSmallUnconformities && hybridScale == null) {
+    let threshold = unconformityHeight ?? 30;
+    if (typeof collapseSmallUnconformities == "number") {
+      threshold = collapseSmallUnconformities;
+    }
+    sectionsWithScales = collapseUnconformitiesByPixelHeight(
+      sectionsWithScales,
+      threshold,
+      options
+    );
+  }
+  let { totalHeight, sections: sections2 } = finalizeSectionHeights(
+    sectionsWithScales,
+    unconformityHeight
+  );
+  const sectionsOut = sections2.map((section) => {
+    return {
+      ...section,
+      units: preprocessUnits(section, axisType)
+    };
+  });
+  const units2 = sectionsOut.reduce((acc, group) => {
+    const { units: units3 } = group;
+    for (const unit of units3) {
+      acc.push(unit);
+    }
+    return acc;
+  }, []);
+  return {
+    units: units2,
+    totalHeight: _totalHeight ?? totalHeight,
+    sections: sectionsOut
+  };
+}
+export {
+  MergeSectionsMode,
+  agesOverlap,
+  createUnitSorter,
+  ensureArray,
+  ensureRealFloat,
+  getPositionWithinUnit,
+  getUnitHeightRange,
+  prepareColumnUnits,
+  preprocessUnits,
+  unitsOverlap,
+  usePreparedColumnUnits
+};
+//# sourceMappingURL=index.js.map

package/dist/prepare-units/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../src/prepare-units/index.ts"],"sourcesContent":["import {\n  getSectionAgeRange,\n  getSectionPosRange,\n  groupUnitsIntoSectionsByOverlap,\n  groupUnitsIntoSectionsBySectionID,\n  mergeOverlappingSections,\n  preprocessSectionUnit,\n  preprocessUnits,\n} from \"./helpers\";\nimport { ColumnAxisType } from \"@macrostrat/column-components\";\nimport { useMemo } from \"react\";\nimport { UnitLong } from \"@macrostrat/api-types\";\nimport {\n  collapseUnconformitiesByPixelHeight,\n  computeSectionHeights,\n  finalizeSectionHeights,\n  type CompositeColumnScale,\n} from \"./composite-scale\";\nimport {\n  agesOverlap,\n  MergeSectionsMode,\n  PrepareColumnOptions,\n  PreparedColumnData,\n  unitsOverlap,\n} from \"./utils\";\nimport { SectionInfo } from \"./types\";\n\nexport * from \"./utils\";\nexport * from \"./types\";\nexport { preprocessUnits };\nexport type { CompositeColumnScale };\n\nexport function usePreparedColumnUnits(\n  data: UnitLong[],\n  options: PrepareColumnOptions,\n): PreparedColumnData {\n  /** This function wraps and memoizes all preparation steps for converting\n   * an array of units from the /units route to a form ready for usage.\n   */\n  return useMemo(() => {\n    return prepareColumnUnits(data, options);\n  }, [data, ...Object.values(options)]);\n}\n\nexport function prepareColumnUnits(\n  units: UnitLong[],\n  options: PrepareColumnOptions,\n): PreparedColumnData {\n  /** Prepare units for rendering into Macrostrat columns */\n\n  let { t_age, b_age, t_pos, b_pos } = options;\n\n  const {\n    mergeSections = MergeSectionsMode.OVERLAPPING,\n    axisType,\n    unconformityHeight,\n    collapseSmallUnconformities = false,\n    hybridScale,\n    scale,\n  } = options;\n\n  let _totalHeight = null;\n\n  if (scale != null) {\n    // Set t_age and b_age based on scale domain if not already set\n    const domain = scale.domain();\n    if (axisType == ColumnAxisType.AGE) {\n      if (t_age == null) t_age = Math.min(...domain);\n      if (b_age == null) b_age = Math.max(...domain);\n      _totalHeight = Math.abs(scale(b_age) - scale(t_age));\n    } else {\n      if (t_pos == null) t_pos = Math.min(...domain);\n      if (b_pos == null) b_pos = Math.max(...domain);\n      _totalHeight = Math.abs(scale(b_pos) - scale(t_pos));\n    }\n  }\n\n  // Start by ensuring that ages and positions are numbers\n  // also set up some values for eODP-style columns\n  let units1 = units.map(preprocessSectionUnit);\n\n  /** Prototype filtering to age range */\n  units1 = units1.filter((d) => {\n    // Filter units by t_age and b_age, inclusive\n    if (axisType == ColumnAxisType.AGE) {\n      return agesOverlap(d, { t_age, b_age });\n    } else {\n      return unitsOverlap(d, { t_pos, b_pos } as any, axisType);\n    }\n  });\n\n  let mergeMode = mergeSections;\n  // if (axisType != ColumnAxisType.AGE) {\n  //   // For non-age columns, we always merge sections.\n  //   // This is because the \"groupUnitsIntoSections\" function is not well-defined\n  //   // for non-age columns.\n  //   mergeMode = MergeSectionsMode.ALL;\n  // }\n\n  let sections0: SectionInfo<UnitLong>[];\n  if (mergeMode == MergeSectionsMode.ALL) {\n    // For the \"merge sections\" mode, we need to create a single section\n    const [b_unit_pos, t_unit_pos] = getSectionPosRange(units1, axisType);\n    const [b_unit_age, t_unit_age] = getSectionAgeRange(units1);\n    sections0 = [\n      {\n        section_id: 0,\n        /**\n         * If ages limits are directly specified, use them to define the section bounds.\n         * */\n        t_pos: t_unit_pos,\n        b_pos: b_unit_pos,\n        t_age: t_unit_age,\n        b_age: b_unit_age,\n        units: units1,\n      },\n    ];\n  } else if (axisType == ColumnAxisType.AGE) {\n    sections0 = groupUnitsIntoSectionsBySectionID(units1, axisType);\n  } else {\n    sections0 = groupUnitsIntoSectionsByOverlap(units1, axisType);\n  }\n\n  // Limit sections to the range specified by t_age/b_age or t_pos/b_pos global options\n  for (let section of sections0) {\n    if (axisType == ColumnAxisType.AGE) {\n      section.t_age = Math.max(section.t_age, t_age ?? -Infinity);\n      section.b_age = Math.min(section.b_age, b_age ?? Infinity);\n    } else if (axisType == ColumnAxisType.DEPTH) {\n      section.t_pos = Math.max(section.t_pos, t_pos ?? -Infinity);\n      section.b_pos = Math.min(section.b_pos, b_pos ?? Infinity);\n    } else if (axisType == ColumnAxisType.HEIGHT) {\n      section.t_pos = Math.max(section.t_pos, t_pos ?? -Infinity);\n      section.b_pos = Math.min(section.b_pos, b_pos ?? Infinity);\n    }\n  }\n\n  /** Merging overlapping sections really only makes sense for age/height/depth\n   * columns. Ordinal columns are numbered by section so merging them\n   * results in collisions.\n   */\n  let sections = sections0;\n  if (\n    mergeSections == MergeSectionsMode.OVERLAPPING &&\n    axisType == ColumnAxisType.AGE\n  ) {\n    sections = mergeOverlappingSections(sections);\n  }\n  // Filter out undefined sections just in case\n  sections = sections.filter((d) => d != null);\n\n  // SCALES\n\n  /* Compute pixel scales etc. for sections\n   * We need to do this now to determine which unconformities\n   * are small enough to collapse.\n   */\n  let sectionsWithScales = computeSectionHeights(sections, options);\n\n  if (collapseSmallUnconformities && hybridScale == null) {\n    // Collapse small unconformities in pixel height space\n    // TODO: this doesn't seem to work properly for non-age columns?\n    let threshold = unconformityHeight ?? 30;\n    if (typeof collapseSmallUnconformities == \"number\") {\n      threshold = collapseSmallUnconformities;\n    }\n\n    sectionsWithScales = collapseUnconformitiesByPixelHeight(\n      sectionsWithScales,\n      threshold,\n      options,\n    );\n  }\n\n  /** Prepare section scale information using groups.\n   * Total height is computed from section scales.\n   * */\n  let { totalHeight, sections: sections2 } = finalizeSectionHeights(\n    sectionsWithScales,\n    unconformityHeight,\n  );\n\n  /** For each section, find units that are overlapping.\n   * We do this after merging sections so that we can\n   * handle cases where there are overlapping units across sections\n   * */\n  const sectionsOut = sections2.map((section) => {\n    return {\n      ...section,\n      units: preprocessUnits(section, axisType),\n    };\n  });\n\n  /** Reconstitute the units so that they are sorted by section and properly enhanced.\n   * This is mostly important so that unit keyboard navigation\n   * predictably selects adjacent units.\n   */\n  const units2 = sectionsOut.reduce((acc, group) => {\n    const { units } = group;\n    for (const unit of units) {\n      acc.push(unit);\n    }\n    return acc;\n  }, []);\n\n  return {\n    units: units2,\n    totalHeight: _totalHeight ?? totalHeight,\n    sections: sectionsOut,\n  };\n}\n"],"names":["units"],"mappings":"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"}

package/dist/prepare-units/types.cjs

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var HybridScaleType = /* @__PURE__ */ ((HybridScaleType2) => {
+  HybridScaleType2["EquidistantSurfaces"] = "equidistant-surfaces";
+  HybridScaleType2["ApproximateHeight"] = "approximate-height";
+  return HybridScaleType2;
+})(HybridScaleType || {});
+var HeightMethod = /* @__PURE__ */ ((HeightMethod2) => {
+  HeightMethod2["Minimum"] = "minimum";
+  HeightMethod2["Average"] = "average";
+  HeightMethod2["Maximum"] = "maximum";
+  return HeightMethod2;
+})(HeightMethod || {});
+exports.HeightMethod = HeightMethod;
+exports.HybridScaleType = HybridScaleType;
+//# sourceMappingURL=types.cjs.map

package/dist/prepare-units/types.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.cjs","sources":["../../src/prepare-units/types.ts"],"sourcesContent":["import type { UnitLong } from \"@macrostrat/api-types\";\nimport type { ColumnAxisType } from \"@macrostrat/column-components\";\nimport type { ScaleContinuousNumeric } from \"d3-scale\";\n\nexport interface ColumnHeightScaleOptions {\n  /** A fixed pixel scale to use for the section (pixels per Myr) */\n  pixelScale?: number;\n  /** The target height of a constituent unit in pixels, for dynamic\n   * scale generation */\n  targetUnitHeight?: number;\n  /** Min height of a section in pixels. Will override minPixelScale in some cases. */\n  minSectionHeight?: number;\n  /** The minimum pixel scale to use for the section (pixels per Myr). This is mostly\n   * needed because small sections (<1-2 units) don't necessarily have space to comfortably\n   * render two axis labels */\n  minPixelScale?: number;\n  // Axis scale type\n  axisType?: ColumnAxisType;\n  // Unconformity height in pixels\n  unconformityHeight?: number;\n  // Whether to collapse unconformities that are less than a height threshold\n  collapseSmallUnconformities?: boolean | number;\n  // A continuous scale to use instead of generating one\n  // TODO: discontinuous scales are not yet supported\n  scale?: ScaleContinuousNumeric<number, number>;\n  // Hybrid scale type.\n  // This overrides parameters such as the axis type\n  hybridScale?: HybridScaleDefinition;\n}\n\nexport enum HybridScaleType {\n  // An age-domain scale that puts equal vertical space between surfaces\n  EquidistantSurfaces = \"equidistant-surfaces\",\n  // A height-domain scale that is based on the average height of units between surfaces\n  ApproximateHeight = \"approximate-height\",\n}\n\nexport enum HeightMethod {\n  Minimum = \"minimum\",\n  Average = \"average\",\n  Maximum = \"maximum\",\n}\n\nexport interface HybridScaleOptions {\n  pixelOffset?: number;\n  pixelScale?: number;\n}\n\nexport type ApproxHeightScaleOptions = {\n  minHeight?: number;\n  defaultHeight?: number;\n  heightMethod?: HeightMethod;\n};\n\nexport type HybridScaleDefinition =\n  | ({\n      type: HybridScaleType.ApproximateHeight;\n    } & ApproxHeightScaleOptions)\n  | {\n      type: HybridScaleType.EquidistantSurfaces;\n    };\n\nexport interface SectionScaleOptions extends ColumnHeightScaleOptions {\n  axisType: ColumnAxisType;\n  domain: [number, number];\n}\n\n/** Output of a section scale. For now, this assumes that the\n * mapping is linear, but it could be extended to support arbitrary\n * scale functions.\n */\nexport interface PackageScaleInfo {\n  domain: [number, number];\n  pixelHeight: number;\n  // TODO: add a function\n  scale: ScaleContinuousNumeric<number, number>;\n  pixelScale?: number; // if it's a linear scale, this could be defined\n  // Subsidiary scale for height mapping (for hybrid scales)\n  heightScale?: ScaleContinuousNumeric<number, number>;\n}\n\nexport type PackageScaleLayoutData = PackageScaleInfo & {\n  // A unique key for the section to use in React\n  key: string;\n  offset: number;\n  // How much to\n  paddingTop: number;\n};\nexport interface StratigraphicPackage {\n  /** A collection of stratigraphic information organized in time, corresponding\n   * to single or multiple columns. */\n  t_age: number;\n  b_age: number;\n}\n\nexport interface SectionInfo<\n  T extends UnitLong = ExtUnit,\n> extends StratigraphicPackage {\n  /** A time-bounded part of a single stratigraphic column. */\n  section_id: number | number[];\n  units: T[];\n  b_pos?: number;\n  t_pos?: number;\n}\n\nexport interface ExtUnit extends UnitLong {\n  bottomOverlap: boolean;\n  overlappingUnits: number[];\n  column?: number;\n  /* Positions (ages or heights) where the unit is clipped to its containing section.\n   * This is relevant if we are filtering by age/height/depth range.\n   */\n  t_clip_pos?: number;\n  b_clip_pos?: number;\n}\n\nexport type PackageLayoutData<T extends UnitLong = ExtUnit> = SectionInfo<T> & {\n  scaleInfo: PackageScaleLayoutData;\n  // A unique key for the section to use in React\n  key: string;\n};\n\nexport interface CompositeScaleData {\n  totalHeight: number;\n  sections: PackageScaleLayoutData[];\n}\n\nexport interface ColumnScaleOptions extends ColumnHeightScaleOptions {\n  axisType: ColumnAxisType;\n  unconformityHeight: number;\n}\n\nexport interface CompositeColumnData<T extends UnitLong = ExtUnit> extends Omit<\n  CompositeScaleData,\n  \"sections\"\n> {\n  sections: PackageLayoutData<T>[];\n}\n"],"names":["HybridScaleType","HeightMethod"],"mappings":";;AA8BO,IAAK,oCAAAA,qBAAL;AAELA,mBAAA,qBAAA,IAAsB;AAEtBA,mBAAA,mBAAA,IAAoB;AAJV,SAAAA;AAAA,GAAA,mBAAA,CAAA,CAAA;AAOL,IAAK,iCAAAC,kBAAL;AACLA,gBAAA,SAAA,IAAU;AACVA,gBAAA,SAAA,IAAU;AACVA,gBAAA,SAAA,IAAU;AAHA,SAAAA;AAAA,GAAA,gBAAA,CAAA,CAAA;;;"}

package/dist/prepare-units/types.d.ts

@@ -0,0 +1,99 @@
+import { UnitLong } from '@macrostrat/api-types';
+import { ColumnAxisType } from '@macrostrat/column-components';
+import { ScaleContinuousNumeric } from 'd3-scale';
+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 */
+    targetUnitHeight?: number;
+    /** Min height of a section in pixels. Will override minPixelScale in some cases. */
+    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 */
+    minPixelScale?: number;
+    axisType?: ColumnAxisType;
+    unconformityHeight?: number;
+    collapseSmallUnconformities?: boolean | number;
+    scale?: ScaleContinuousNumeric<number, number>;
+    hybridScale?: HybridScaleDefinition;
+}
+export declare enum HybridScaleType {
+    EquidistantSurfaces = "equidistant-surfaces",
+    ApproximateHeight = "approximate-height"
+}
+export declare enum HeightMethod {
+    Minimum = "minimum",
+    Average = "average",
+    Maximum = "maximum"
+}
+export interface HybridScaleOptions {
+    pixelOffset?: number;
+    pixelScale?: number;
+}
+export type ApproxHeightScaleOptions = {
+    minHeight?: number;
+    defaultHeight?: number;
+    heightMethod?: HeightMethod;
+};
+export type HybridScaleDefinition = ({
+    type: HybridScaleType.ApproximateHeight;
+} & ApproxHeightScaleOptions) | {
+    type: HybridScaleType.EquidistantSurfaces;
+};
+export interface SectionScaleOptions extends ColumnHeightScaleOptions {
+    axisType: ColumnAxisType;
+    domain: [number, number];
+}
+/** Output of a section scale. For now, this assumes that the
+ * mapping is linear, but it could be extended to support arbitrary
+ * scale functions.
+ */
+export interface PackageScaleInfo {
+    domain: [number, number];
+    pixelHeight: number;
+    scale: ScaleContinuousNumeric<number, number>;
+    pixelScale?: number;
+    heightScale?: ScaleContinuousNumeric<number, number>;
+}
+export type PackageScaleLayoutData = PackageScaleInfo & {
+    key: string;
+    offset: number;
+    paddingTop: number;
+};
+export interface StratigraphicPackage {
+    /** A collection of stratigraphic information organized in time, corresponding
+     * to single or multiple columns. */
+    t_age: number;
+    b_age: number;
+}
+export interface SectionInfo<T extends UnitLong = ExtUnit> extends StratigraphicPackage {
+    /** A time-bounded part of a single stratigraphic column. */
+    section_id: number | number[];
+    units: T[];
+    b_pos?: number;
+    t_pos?: number;
+}
+export interface ExtUnit extends UnitLong {
+    bottomOverlap: boolean;
+    overlappingUnits: number[];
+    column?: number;
+    t_clip_pos?: number;
+    b_clip_pos?: number;
+}
+export type PackageLayoutData<T extends UnitLong = ExtUnit> = SectionInfo<T> & {
+    scaleInfo: PackageScaleLayoutData;
+    key: string;
+};
+export interface CompositeScaleData {
+    totalHeight: number;
+    sections: PackageScaleLayoutData[];
+}
+export interface ColumnScaleOptions extends ColumnHeightScaleOptions {
+    axisType: ColumnAxisType;
+    unconformityHeight: number;
+}
+export interface CompositeColumnData<T extends UnitLong = ExtUnit> extends Omit<CompositeScaleData, "sections"> {
+    sections: PackageLayoutData<T>[];
+}

package/dist/prepare-units/types.js

@@ -0,0 +1,16 @@
+var HybridScaleType = /* @__PURE__ */ ((HybridScaleType2) => {
+  HybridScaleType2["EquidistantSurfaces"] = "equidistant-surfaces";
+  HybridScaleType2["ApproximateHeight"] = "approximate-height";
+  return HybridScaleType2;
+})(HybridScaleType || {});
+var HeightMethod = /* @__PURE__ */ ((HeightMethod2) => {
+  HeightMethod2["Minimum"] = "minimum";
+  HeightMethod2["Average"] = "average";
+  HeightMethod2["Maximum"] = "maximum";
+  return HeightMethod2;
+})(HeightMethod || {});
+export {
+  HeightMethod,
+  HybridScaleType
+};
+//# sourceMappingURL=types.js.map

package/dist/prepare-units/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sources":["../../src/prepare-units/types.ts"],"sourcesContent":["import type { UnitLong } from \"@macrostrat/api-types\";\nimport type { ColumnAxisType } from \"@macrostrat/column-components\";\nimport type { ScaleContinuousNumeric } from \"d3-scale\";\n\nexport interface ColumnHeightScaleOptions {\n  /** A fixed pixel scale to use for the section (pixels per Myr) */\n  pixelScale?: number;\n  /** The target height of a constituent unit in pixels, for dynamic\n   * scale generation */\n  targetUnitHeight?: number;\n  /** Min height of a section in pixels. Will override minPixelScale in some cases. */\n  minSectionHeight?: number;\n  /** The minimum pixel scale to use for the section (pixels per Myr). This is mostly\n   * needed because small sections (<1-2 units) don't necessarily have space to comfortably\n   * render two axis labels */\n  minPixelScale?: number;\n  // Axis scale type\n  axisType?: ColumnAxisType;\n  // Unconformity height in pixels\n  unconformityHeight?: number;\n  // Whether to collapse unconformities that are less than a height threshold\n  collapseSmallUnconformities?: boolean | number;\n  // A continuous scale to use instead of generating one\n  // TODO: discontinuous scales are not yet supported\n  scale?: ScaleContinuousNumeric<number, number>;\n  // Hybrid scale type.\n  // This overrides parameters such as the axis type\n  hybridScale?: HybridScaleDefinition;\n}\n\nexport enum HybridScaleType {\n  // An age-domain scale that puts equal vertical space between surfaces\n  EquidistantSurfaces = \"equidistant-surfaces\",\n  // A height-domain scale that is based on the average height of units between surfaces\n  ApproximateHeight = \"approximate-height\",\n}\n\nexport enum HeightMethod {\n  Minimum = \"minimum\",\n  Average = \"average\",\n  Maximum = \"maximum\",\n}\n\nexport interface HybridScaleOptions {\n  pixelOffset?: number;\n  pixelScale?: number;\n}\n\nexport type ApproxHeightScaleOptions = {\n  minHeight?: number;\n  defaultHeight?: number;\n  heightMethod?: HeightMethod;\n};\n\nexport type HybridScaleDefinition =\n  | ({\n      type: HybridScaleType.ApproximateHeight;\n    } & ApproxHeightScaleOptions)\n  | {\n      type: HybridScaleType.EquidistantSurfaces;\n    };\n\nexport interface SectionScaleOptions extends ColumnHeightScaleOptions {\n  axisType: ColumnAxisType;\n  domain: [number, number];\n}\n\n/** Output of a section scale. For now, this assumes that the\n * mapping is linear, but it could be extended to support arbitrary\n * scale functions.\n */\nexport interface PackageScaleInfo {\n  domain: [number, number];\n  pixelHeight: number;\n  // TODO: add a function\n  scale: ScaleContinuousNumeric<number, number>;\n  pixelScale?: number; // if it's a linear scale, this could be defined\n  // Subsidiary scale for height mapping (for hybrid scales)\n  heightScale?: ScaleContinuousNumeric<number, number>;\n}\n\nexport type PackageScaleLayoutData = PackageScaleInfo & {\n  // A unique key for the section to use in React\n  key: string;\n  offset: number;\n  // How much to\n  paddingTop: number;\n};\nexport interface StratigraphicPackage {\n  /** A collection of stratigraphic information organized in time, corresponding\n   * to single or multiple columns. */\n  t_age: number;\n  b_age: number;\n}\n\nexport interface SectionInfo<\n  T extends UnitLong = ExtUnit,\n> extends StratigraphicPackage {\n  /** A time-bounded part of a single stratigraphic column. */\n  section_id: number | number[];\n  units: T[];\n  b_pos?: number;\n  t_pos?: number;\n}\n\nexport interface ExtUnit extends UnitLong {\n  bottomOverlap: boolean;\n  overlappingUnits: number[];\n  column?: number;\n  /* Positions (ages or heights) where the unit is clipped to its containing section.\n   * This is relevant if we are filtering by age/height/depth range.\n   */\n  t_clip_pos?: number;\n  b_clip_pos?: number;\n}\n\nexport type PackageLayoutData<T extends UnitLong = ExtUnit> = SectionInfo<T> & {\n  scaleInfo: PackageScaleLayoutData;\n  // A unique key for the section to use in React\n  key: string;\n};\n\nexport interface CompositeScaleData {\n  totalHeight: number;\n  sections: PackageScaleLayoutData[];\n}\n\nexport interface ColumnScaleOptions extends ColumnHeightScaleOptions {\n  axisType: ColumnAxisType;\n  unconformityHeight: number;\n}\n\nexport interface CompositeColumnData<T extends UnitLong = ExtUnit> extends Omit<\n  CompositeScaleData,\n  \"sections\"\n> {\n  sections: PackageLayoutData<T>[];\n}\n"],"names":["HybridScaleType","HeightMethod"],"mappings":"AA8BO,IAAK,oCAAAA,qBAAL;AAELA,mBAAA,qBAAA,IAAsB;AAEtBA,mBAAA,mBAAA,IAAoB;AAJV,SAAAA;AAAA,GAAA,mBAAA,CAAA,CAAA;AAOL,IAAK,iCAAAC,kBAAL;AACLA,gBAAA,SAAA,IAAU;AACVA,gBAAA,SAAA,IAAU;AACVA,gBAAA,SAAA,IAAU;AAHA,SAAAA;AAAA,GAAA,gBAAA,CAAA,CAAA;"}

package/dist/prepare-units/utils.cjs

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const stratigraphyUtils = require("@macrostrat/stratigraphy-utils");
+const columnComponents = require("@macrostrat/column-components");
+const dt = 1e-3;
+var MergeSectionsMode = /* @__PURE__ */ ((MergeSectionsMode2) => {
+  MergeSectionsMode2["ALL"] = "all";
+  MergeSectionsMode2["OVERLAPPING"] = "overlapping";
+  return MergeSectionsMode2;
+})(MergeSectionsMode || {});
+const unitsOverlap = function(a, b, axisType = columnComponents.ColumnAxisType.AGE, tolerance = 1e-3) {
+  const rel = stratigraphyUtils.compareAgeRanges(
+    getUnitHeightRange(a, axisType),
+    getUnitHeightRange(b, axisType),
+    tolerance
+  );
+  return rel != stratigraphyUtils.AgeRangeRelationship.Disjoint;
+};
+function agesOverlap(a, b, tolerance = dt) {
+  return unitsOverlap(a, b, columnComponents.ColumnAxisType.AGE, tolerance);
+}
+function getUnitHeightRange(unit, axisType, clipped = true) {
+  if (clipped) {
+    switch (axisType) {
+      case columnComponents.ColumnAxisType.AGE:
+        return [unit.b_clip_pos ?? unit.b_age, unit.t_clip_pos ?? unit.t_age];
+      case columnComponents.ColumnAxisType.DEPTH:
+      case columnComponents.ColumnAxisType.ORDINAL:
+      case columnComponents.ColumnAxisType.HEIGHT:
+        return [unit.b_clip_pos ?? unit.b_pos, unit.t_clip_pos ?? unit.t_pos];
+      default:
+        throw new Error(`Unknown axis type: ${axisType}`);
+    }
+  } else {
+    switch (axisType) {
+      case columnComponents.ColumnAxisType.AGE:
+        return [unit.b_age, unit.t_age];
+      case columnComponents.ColumnAxisType.DEPTH:
+      case columnComponents.ColumnAxisType.ORDINAL:
+      case columnComponents.ColumnAxisType.HEIGHT:
+        return [unit.b_pos, unit.t_pos];
+      default:
+        throw new Error(`Unknown axis type: ${axisType}`);
+    }
+  }
+}
+function getPositionWithinUnit(position, unit, axisType) {
+  if (position < 0 || position > 1) {
+    throw new Error(`Position must be between 0 and 1: ${position}`);
+  }
+  const [pos_bottom, pos_top] = getUnitHeightRange(unit, axisType, false);
+  const abs_pos = pos_bottom + position * (pos_top - pos_bottom);
+  const [clip_bottom, clip_top] = getUnitHeightRange(unit, axisType, true);
+  if (axisType === columnComponents.ColumnAxisType.AGE || axisType === columnComponents.ColumnAxisType.DEPTH) {
+    if (abs_pos > clip_bottom || abs_pos < clip_top) {
+      return null;
+    }
+  } else {
+    if (abs_pos < clip_bottom || abs_pos > clip_top) {
+      return null;
+    }
+  }
+  return abs_pos;
+}
+const createUnitSorter = (axisType) => {
+  return (a, b) => {
+    const a_pos = getUnitHeightRange(a, axisType);
+    const b_pos = getUnitHeightRange(b, axisType);
+    const d_top = a_pos[1] - b_pos[1];
+    if (d_top != 0) {
+      return d_top;
+    }
+    return a_pos[0] - b_pos[0];
+  };
+};
+function ensureArray(x) {
+  if (Array.isArray(x)) {
+    return x;
+  }
+  return [x];
+}
+function ensureRealFloat(x) {
+  if (typeof x == "string") {
+    x = parseFloat(x);
+  }
+  if (isNaN(x)) {
+    return null;
+  }
+  return x;
+}
+exports.MergeSectionsMode = MergeSectionsMode;
+exports.agesOverlap = agesOverlap;
+exports.createUnitSorter = createUnitSorter;
+exports.ensureArray = ensureArray;
+exports.ensureRealFloat = ensureRealFloat;
+exports.getPositionWithinUnit = getPositionWithinUnit;
+exports.getUnitHeightRange = getUnitHeightRange;
+exports.unitsOverlap = unitsOverlap;
+//# sourceMappingURL=utils.cjs.map

package/dist/prepare-units/utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.cjs","sources":["../../src/prepare-units/utils.ts"],"sourcesContent":["import type { BaseUnit } from \"@macrostrat/api-types\";\nimport {\n  AgeRangeRelationship,\n  compareAgeRanges,\n} from \"@macrostrat/stratigraphy-utils\";\nimport { ColumnAxisType } from \"@macrostrat/column-components\";\nimport { ScaleContinuousNumeric } from \"d3-scale\";\nimport type {\n  ColumnScaleOptions,\n  CompositeColumnData,\n  ExtUnit,\n  PackageLayoutData,\n  StratigraphicPackage,\n} from \"./types\";\n\nconst dt = 0.001;\n\nexport interface PrepareColumnOptions extends ColumnScaleOptions {\n  axisType: ColumnAxisType;\n  t_age?: number;\n  b_age?: number;\n  t_pos?: number;\n  b_pos?: number;\n  mergeSections?: MergeSectionsMode;\n  collapseSmallUnconformities?: boolean | number;\n  scale?: ScaleContinuousNumeric<any, any>;\n}\n\nexport enum MergeSectionsMode {\n  ALL = \"all\",\n  OVERLAPPING = \"overlapping\",\n}\n\nexport interface PreparedColumnData extends CompositeColumnData {\n  sections: PackageLayoutData[];\n  units: ExtUnit[];\n}\n\ninterface UnitsOverlap {\n  (\n    a: StratigraphicPackage,\n    b: StratigraphicPackage,\n    axisType?: ColumnAxisType.AGE,\n    tolerance?: number,\n  ): boolean;\n  (\n    a: BaseUnit,\n    b: BaseUnit,\n    axisType: ColumnAxisType,\n    tolerance?: number,\n  ): boolean;\n}\n\nexport const unitsOverlap: UnitsOverlap = function (\n  a,\n  b,\n  axisType: ColumnAxisType = ColumnAxisType.AGE,\n  tolerance: number = 0.001,\n): boolean {\n  const rel = compareAgeRanges(\n    getUnitHeightRange(a, axisType),\n    getUnitHeightRange(b, axisType),\n    tolerance,\n  );\n  return rel != AgeRangeRelationship.Disjoint;\n};\n\n/** A more permissive overlap function in the age space */\nexport function agesOverlap(\n  a: StratigraphicPackage,\n  b: StratigraphicPackage,\n  tolerance: number = dt,\n): boolean {\n  return unitsOverlap(a, b, ColumnAxisType.AGE, tolerance);\n}\n\nexport interface PossiblyClippedUnit extends BaseUnit {\n  // Internally created clipped positions\n  t_clip_pos?: number;\n  b_clip_pos?: number;\n}\n\nexport function getUnitHeightRange(\n  unit: PossiblyClippedUnit,\n  axisType: ColumnAxisType,\n  clipped: boolean = true,\n): [number, number] {\n  if (clipped) {\n    switch (axisType) {\n      case ColumnAxisType.AGE:\n        return [unit.b_clip_pos ?? unit.b_age, unit.t_clip_pos ?? unit.t_age];\n      case ColumnAxisType.DEPTH:\n      case ColumnAxisType.ORDINAL:\n      case ColumnAxisType.HEIGHT:\n        return [unit.b_clip_pos ?? unit.b_pos, unit.t_clip_pos ?? unit.t_pos];\n      default:\n        throw new Error(`Unknown axis type: ${axisType}`);\n    }\n  } else {\n    switch (axisType) {\n      case ColumnAxisType.AGE:\n        return [unit.b_age, unit.t_age];\n      case ColumnAxisType.DEPTH:\n      case ColumnAxisType.ORDINAL:\n      case ColumnAxisType.HEIGHT:\n        return [unit.b_pos, unit.t_pos];\n      default:\n        throw new Error(`Unknown axis type: ${axisType}`);\n    }\n  }\n}\n\nexport function getPositionWithinUnit(\n  position: number,\n  unit: PossiblyClippedUnit,\n  axisType: ColumnAxisType,\n): number | null {\n  /** Translate a relative position (0-1) within a unit to an absolute position\n   * within the unit's height range. If the unit is clipped, null values will be\n   * returned for positions outside the clip range\n   */\n  if (position < 0 || position > 1) {\n    throw new Error(`Position must be between 0 and 1: ${position}`);\n  }\n\n  const [pos_bottom, pos_top] = getUnitHeightRange(unit, axisType, false);\n  const abs_pos = pos_bottom + position * (pos_top - pos_bottom);\n\n  // If clipped, check if abs_pos is within the clipped range\n  const [clip_bottom, clip_top] = getUnitHeightRange(unit, axisType, true);\n  if (axisType === ColumnAxisType.AGE || axisType === ColumnAxisType.DEPTH) {\n    // Invert for age/depth axes\n    if (abs_pos > clip_bottom || abs_pos < clip_top) {\n      return null;\n    }\n  } else {\n    if (abs_pos < clip_bottom || abs_pos > clip_top) {\n      return null;\n    }\n  }\n\n  return abs_pos;\n}\n\nexport const createUnitSorter = (axisType: ColumnAxisType) => {\n  return (a: BaseUnit, b: BaseUnit) => {\n    const a_pos = getUnitHeightRange(a, axisType);\n    const b_pos = getUnitHeightRange(b, axisType);\n    const d_top = a_pos[1] - b_pos[1];\n    if (d_top != 0) {\n      return d_top;\n    }\n    return a_pos[0] - b_pos[0];\n  };\n};\n\nexport function ensureArray<T>(x: T | T[]): T[] {\n  if (Array.isArray(x)) {\n    return x;\n  }\n  return [x];\n}\n\nexport function ensureRealFloat(x: number | string | null): number | null {\n  if (typeof x == \"string\") {\n    x = parseFloat(x);\n  }\n  if (isNaN(x)) {\n    return null;\n  }\n  return x;\n}\n"],"names":["MergeSectionsMode","ColumnAxisType","compareAgeRanges","AgeRangeRelationship"],"mappings":"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"}

package/dist/prepare-units/utils.d.ts

@@ -0,0 +1,39 @@
+import { BaseUnit } from '@macrostrat/api-types';
+import { ColumnAxisType } from '@macrostrat/column-components';
+import { ScaleContinuousNumeric } from 'd3-scale';
+import { ColumnScaleOptions, CompositeColumnData, ExtUnit, PackageLayoutData, StratigraphicPackage } from './types';
+export interface PrepareColumnOptions extends ColumnScaleOptions {
+    axisType: ColumnAxisType;
+    t_age?: number;
+    b_age?: number;
+    t_pos?: number;
+    b_pos?: number;
+    mergeSections?: MergeSectionsMode;
+    collapseSmallUnconformities?: boolean | number;
+    scale?: ScaleContinuousNumeric<any, any>;
+}
+export declare enum MergeSectionsMode {
+    ALL = "all",
+    OVERLAPPING = "overlapping"
+}
+export interface PreparedColumnData extends CompositeColumnData {
+    sections: PackageLayoutData[];
+    units: ExtUnit[];
+}
+interface UnitsOverlap {
+    (a: StratigraphicPackage, b: StratigraphicPackage, axisType?: ColumnAxisType.AGE, tolerance?: number): boolean;
+    (a: BaseUnit, b: BaseUnit, axisType: ColumnAxisType, tolerance?: number): boolean;
+}
+export declare const unitsOverlap: UnitsOverlap;
+/** A more permissive overlap function in the age space */
+export declare function agesOverlap(a: StratigraphicPackage, b: StratigraphicPackage, tolerance?: number): boolean;
+export interface PossiblyClippedUnit extends BaseUnit {
+    t_clip_pos?: number;
+    b_clip_pos?: number;
+}
+export declare function getUnitHeightRange(unit: PossiblyClippedUnit, axisType: ColumnAxisType, clipped?: boolean): [number, number];
+export declare function getPositionWithinUnit(position: number, unit: PossiblyClippedUnit, axisType: ColumnAxisType): number | null;
+export declare const createUnitSorter: (axisType: ColumnAxisType) => (a: BaseUnit, b: BaseUnit) => number;
+export declare function ensureArray<T>(x: T | T[]): T[];
+export declare function ensureRealFloat(x: number | string | null): number | null;
+export {};

package/dist/prepare-units/utils.js

@@ -0,0 +1,99 @@
+import { compareAgeRanges, AgeRangeRelationship } from "@macrostrat/stratigraphy-utils";
+import { ColumnAxisType } from "@macrostrat/column-components";
+const dt = 1e-3;
+var MergeSectionsMode = /* @__PURE__ */ ((MergeSectionsMode2) => {
+  MergeSectionsMode2["ALL"] = "all";
+  MergeSectionsMode2["OVERLAPPING"] = "overlapping";
+  return MergeSectionsMode2;
+})(MergeSectionsMode || {});
+const unitsOverlap = function(a, b, axisType = ColumnAxisType.AGE, tolerance = 1e-3) {
+  const rel = compareAgeRanges(
+    getUnitHeightRange(a, axisType),
+    getUnitHeightRange(b, axisType),
+    tolerance
+  );
+  return rel != AgeRangeRelationship.Disjoint;
+};
+function agesOverlap(a, b, tolerance = dt) {
+  return unitsOverlap(a, b, ColumnAxisType.AGE, tolerance);
+}
+function getUnitHeightRange(unit, axisType, clipped = true) {
+  if (clipped) {
+    switch (axisType) {
+      case ColumnAxisType.AGE:
+        return [unit.b_clip_pos ?? unit.b_age, unit.t_clip_pos ?? unit.t_age];
+      case ColumnAxisType.DEPTH:
+      case ColumnAxisType.ORDINAL:
+      case ColumnAxisType.HEIGHT:
+        return [unit.b_clip_pos ?? unit.b_pos, unit.t_clip_pos ?? unit.t_pos];
+      default:
+        throw new Error(`Unknown axis type: ${axisType}`);
+    }
+  } else {
+    switch (axisType) {
+      case ColumnAxisType.AGE:
+        return [unit.b_age, unit.t_age];
+      case ColumnAxisType.DEPTH:
+      case ColumnAxisType.ORDINAL:
+      case ColumnAxisType.HEIGHT:
+        return [unit.b_pos, unit.t_pos];
+      default:
+        throw new Error(`Unknown axis type: ${axisType}`);
+    }
+  }
+}
+function getPositionWithinUnit(position, unit, axisType) {
+  if (position < 0 || position > 1) {
+    throw new Error(`Position must be between 0 and 1: ${position}`);
+  }
+  const [pos_bottom, pos_top] = getUnitHeightRange(unit, axisType, false);
+  const abs_pos = pos_bottom + position * (pos_top - pos_bottom);
+  const [clip_bottom, clip_top] = getUnitHeightRange(unit, axisType, true);
+  if (axisType === ColumnAxisType.AGE || axisType === ColumnAxisType.DEPTH) {
+    if (abs_pos > clip_bottom || abs_pos < clip_top) {
+      return null;
+    }
+  } else {
+    if (abs_pos < clip_bottom || abs_pos > clip_top) {
+      return null;
+    }
+  }
+  return abs_pos;
+}
+const createUnitSorter = (axisType) => {
+  return (a, b) => {
+    const a_pos = getUnitHeightRange(a, axisType);
+    const b_pos = getUnitHeightRange(b, axisType);
+    const d_top = a_pos[1] - b_pos[1];
+    if (d_top != 0) {
+      return d_top;
+    }
+    return a_pos[0] - b_pos[0];
+  };
+};
+function ensureArray(x) {
+  if (Array.isArray(x)) {
+    return x;
+  }
+  return [x];
+}
+function ensureRealFloat(x) {
+  if (typeof x == "string") {
+    x = parseFloat(x);
+  }
+  if (isNaN(x)) {
+    return null;
+  }
+  return x;
+}
+export {
+  MergeSectionsMode,
+  agesOverlap,
+  createUnitSorter,
+  ensureArray,
+  ensureRealFloat,
+  getPositionWithinUnit,
+  getUnitHeightRange,
+  unitsOverlap
+};
+//# sourceMappingURL=utils.js.map

package/dist/prepare-units/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":["../../src/prepare-units/utils.ts"],"sourcesContent":["import type { BaseUnit } from \"@macrostrat/api-types\";\nimport {\n  AgeRangeRelationship,\n  compareAgeRanges,\n} from \"@macrostrat/stratigraphy-utils\";\nimport { ColumnAxisType } from \"@macrostrat/column-components\";\nimport { ScaleContinuousNumeric } from \"d3-scale\";\nimport type {\n  ColumnScaleOptions,\n  CompositeColumnData,\n  ExtUnit,\n  PackageLayoutData,\n  StratigraphicPackage,\n} from \"./types\";\n\nconst dt = 0.001;\n\nexport interface PrepareColumnOptions extends ColumnScaleOptions {\n  axisType: ColumnAxisType;\n  t_age?: number;\n  b_age?: number;\n  t_pos?: number;\n  b_pos?: number;\n  mergeSections?: MergeSectionsMode;\n  collapseSmallUnconformities?: boolean | number;\n  scale?: ScaleContinuousNumeric<any, any>;\n}\n\nexport enum MergeSectionsMode {\n  ALL = \"all\",\n  OVERLAPPING = \"overlapping\",\n}\n\nexport interface PreparedColumnData extends CompositeColumnData {\n  sections: PackageLayoutData[];\n  units: ExtUnit[];\n}\n\ninterface UnitsOverlap {\n  (\n    a: StratigraphicPackage,\n    b: StratigraphicPackage,\n    axisType?: ColumnAxisType.AGE,\n    tolerance?: number,\n  ): boolean;\n  (\n    a: BaseUnit,\n    b: BaseUnit,\n    axisType: ColumnAxisType,\n    tolerance?: number,\n  ): boolean;\n}\n\nexport const unitsOverlap: UnitsOverlap = function (\n  a,\n  b,\n  axisType: ColumnAxisType = ColumnAxisType.AGE,\n  tolerance: number = 0.001,\n): boolean {\n  const rel = compareAgeRanges(\n    getUnitHeightRange(a, axisType),\n    getUnitHeightRange(b, axisType),\n    tolerance,\n  );\n  return rel != AgeRangeRelationship.Disjoint;\n};\n\n/** A more permissive overlap function in the age space */\nexport function agesOverlap(\n  a: StratigraphicPackage,\n  b: StratigraphicPackage,\n  tolerance: number = dt,\n): boolean {\n  return unitsOverlap(a, b, ColumnAxisType.AGE, tolerance);\n}\n\nexport interface PossiblyClippedUnit extends BaseUnit {\n  // Internally created clipped positions\n  t_clip_pos?: number;\n  b_clip_pos?: number;\n}\n\nexport function getUnitHeightRange(\n  unit: PossiblyClippedUnit,\n  axisType: ColumnAxisType,\n  clipped: boolean = true,\n): [number, number] {\n  if (clipped) {\n    switch (axisType) {\n      case ColumnAxisType.AGE:\n        return [unit.b_clip_pos ?? unit.b_age, unit.t_clip_pos ?? unit.t_age];\n      case ColumnAxisType.DEPTH:\n      case ColumnAxisType.ORDINAL:\n      case ColumnAxisType.HEIGHT:\n        return [unit.b_clip_pos ?? unit.b_pos, unit.t_clip_pos ?? unit.t_pos];\n      default:\n        throw new Error(`Unknown axis type: ${axisType}`);\n    }\n  } else {\n    switch (axisType) {\n      case ColumnAxisType.AGE:\n        return [unit.b_age, unit.t_age];\n      case ColumnAxisType.DEPTH:\n      case ColumnAxisType.ORDINAL:\n      case ColumnAxisType.HEIGHT:\n        return [unit.b_pos, unit.t_pos];\n      default:\n        throw new Error(`Unknown axis type: ${axisType}`);\n    }\n  }\n}\n\nexport function getPositionWithinUnit(\n  position: number,\n  unit: PossiblyClippedUnit,\n  axisType: ColumnAxisType,\n): number | null {\n  /** Translate a relative position (0-1) within a unit to an absolute position\n   * within the unit's height range. If the unit is clipped, null values will be\n   * returned for positions outside the clip range\n   */\n  if (position < 0 || position > 1) {\n    throw new Error(`Position must be between 0 and 1: ${position}`);\n  }\n\n  const [pos_bottom, pos_top] = getUnitHeightRange(unit, axisType, false);\n  const abs_pos = pos_bottom + position * (pos_top - pos_bottom);\n\n  // If clipped, check if abs_pos is within the clipped range\n  const [clip_bottom, clip_top] = getUnitHeightRange(unit, axisType, true);\n  if (axisType === ColumnAxisType.AGE || axisType === ColumnAxisType.DEPTH) {\n    // Invert for age/depth axes\n    if (abs_pos > clip_bottom || abs_pos < clip_top) {\n      return null;\n    }\n  } else {\n    if (abs_pos < clip_bottom || abs_pos > clip_top) {\n      return null;\n    }\n  }\n\n  return abs_pos;\n}\n\nexport const createUnitSorter = (axisType: ColumnAxisType) => {\n  return (a: BaseUnit, b: BaseUnit) => {\n    const a_pos = getUnitHeightRange(a, axisType);\n    const b_pos = getUnitHeightRange(b, axisType);\n    const d_top = a_pos[1] - b_pos[1];\n    if (d_top != 0) {\n      return d_top;\n    }\n    return a_pos[0] - b_pos[0];\n  };\n};\n\nexport function ensureArray<T>(x: T | T[]): T[] {\n  if (Array.isArray(x)) {\n    return x;\n  }\n  return [x];\n}\n\nexport function ensureRealFloat(x: number | string | null): number | null {\n  if (typeof x == \"string\") {\n    x = parseFloat(x);\n  }\n  if (isNaN(x)) {\n    return null;\n  }\n  return x;\n}\n"],"names":["MergeSectionsMode"],"mappings":";;AAeA,MAAM,KAAK;AAaJ,IAAK,sCAAAA,uBAAL;AACLA,qBAAA,KAAA,IAAM;AACNA,qBAAA,aAAA,IAAc;AAFJ,SAAAA;AAAA,GAAA,qBAAA,CAAA,CAAA;AAyBL,MAAM,eAA6B,SACxC,GACA,GACA,WAA2B,eAAe,KAC1C,YAAoB,MACX;AACT,QAAM,MAAM;AAAA,IACV,mBAAmB,GAAG,QAAQ;AAAA,IAC9B,mBAAmB,GAAG,QAAQ;AAAA,IAC9B;AAAA,EAAA;AAEF,SAAO,OAAO,qBAAqB;AACrC;AAGO,SAAS,YACd,GACA,GACA,YAAoB,IACX;AACT,SAAO,aAAa,GAAG,GAAG,eAAe,KAAK,SAAS;AACzD;AAQO,SAAS,mBACd,MACA,UACA,UAAmB,MACD;AAClB,MAAI,SAAS;AACX,YAAQ,UAAA;AAAA,MACN,KAAK,eAAe;AAClB,eAAO,CAAC,KAAK,cAAc,KAAK,OAAO,KAAK,cAAc,KAAK,KAAK;AAAA,MACtE,KAAK,eAAe;AAAA,MACpB,KAAK,eAAe;AAAA,MACpB,KAAK,eAAe;AAClB,eAAO,CAAC,KAAK,cAAc,KAAK,OAAO,KAAK,cAAc,KAAK,KAAK;AAAA,MACtE;AACE,cAAM,IAAI,MAAM,sBAAsB,QAAQ,EAAE;AAAA,IAAA;AAAA,EAEtD,OAAO;AACL,YAAQ,UAAA;AAAA,MACN,KAAK,eAAe;AAClB,eAAO,CAAC,KAAK,OAAO,KAAK,KAAK;AAAA,MAChC,KAAK,eAAe;AAAA,MACpB,KAAK,eAAe;AAAA,MACpB,KAAK,eAAe;AAClB,eAAO,CAAC,KAAK,OAAO,KAAK,KAAK;AAAA,MAChC;AACE,cAAM,IAAI,MAAM,sBAAsB,QAAQ,EAAE;AAAA,IAAA;AAAA,EAEtD;AACF;AAEO,SAAS,sBACd,UACA,MACA,UACe;AAKf,MAAI,WAAW,KAAK,WAAW,GAAG;AAChC,UAAM,IAAI,MAAM,qCAAqC,QAAQ,EAAE;AAAA,EACjE;AAEA,QAAM,CAAC,YAAY,OAAO,IAAI,mBAAmB,MAAM,UAAU,KAAK;AACtE,QAAM,UAAU,aAAa,YAAY,UAAU;AAGnD,QAAM,CAAC,aAAa,QAAQ,IAAI,mBAAmB,MAAM,UAAU,IAAI;AACvE,MAAI,aAAa,eAAe,OAAO,aAAa,eAAe,OAAO;AAExE,QAAI,UAAU,eAAe,UAAU,UAAU;AAC/C,aAAO;AAAA,IACT;AAAA,EACF,OAAO;AACL,QAAI,UAAU,eAAe,UAAU,UAAU;AAC/C,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO;AACT;AAEO,MAAM,mBAAmB,CAAC,aAA6B;AAC5D,SAAO,CAAC,GAAa,MAAgB;AACnC,UAAM,QAAQ,mBAAmB,GAAG,QAAQ;AAC5C,UAAM,QAAQ,mBAAmB,GAAG,QAAQ;AAC5C,UAAM,QAAQ,MAAM,CAAC,IAAI,MAAM,CAAC;AAChC,QAAI,SAAS,GAAG;AACd,aAAO;AAAA,IACT;AACA,WAAO,MAAM,CAAC,IAAI,MAAM,CAAC;AAAA,EAC3B;AACF;AAEO,SAAS,YAAe,GAAiB;AAC9C,MAAI,MAAM,QAAQ,CAAC,GAAG;AACpB,WAAO;AAAA,EACT;AACA,SAAO,CAAC,CAAC;AACX;AAEO,SAAS,gBAAgB,GAA0C;AACxE,MAAI,OAAO,KAAK,UAAU;AACxB,QAAI,WAAW,CAAC;AAAA,EAClB;AACA,MAAI,MAAM,CAAC,GAAG;AACZ,WAAO;AAAA,EACT;AACA,SAAO;AACT;"}