@macrostrat/column-views 2.4.3 → 3.0.0

package/dist/prepare-units/helpers.cjs

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const d3Array = require("d3-array");
+const columnComponents = require("@macrostrat/column-components");
+const utils = require("./utils.cjs");
+const stratigraphyUtils = require("@macrostrat/stratigraphy-utils");
+const dt = 1e-3;
+function preprocessUnits(section, axisType = columnComponents.ColumnAxisType.AGE) {
+  let units = section.units;
+  let divisions = units.map((...args) => extendDivision(...args, axisType));
+  for (let d of divisions) {
+    const overlappingUnits = divisions.filter(
+      (u) => d.overlappingUnits.includes(u.unit_id)
+    );
+    const columns = overlappingUnits.map((d2) => d2.column);
+    if (columns.includes(d.column)) {
+      let col = 0;
+      while (columns.includes(col)) {
+        col++;
+      }
+      d.column ??= col;
+    }
+    const [b_pos, t_pos] = utils.getUnitHeightRange(d, axisType);
+    if (axisType == columnComponents.ColumnAxisType.AGE) {
+      if (b_pos > section.b_age) {
+        d.b_clip_pos = section.b_age;
+      }
+      if (t_pos < section.t_age) {
+        d.t_clip_pos = section.t_age;
+      }
+    }
+    if (axisType == columnComponents.ColumnAxisType.DEPTH) {
+      if (b_pos > section.b_pos) {
+        d.b_clip_pos = section.b_pos;
+      }
+      if (t_pos < section.t_pos) {
+        d.t_clip_pos = section.t_pos;
+      }
+    }
+  }
+  return divisions;
+}
+function extendDivision(unit, i, divisions, axisType = columnComponents.ColumnAxisType.AGE) {
+  let tolerance = 1e-3;
+  if (axisType != columnComponents.ColumnAxisType.AGE) {
+    tolerance = 0.01;
+  }
+  const overlappingUnits = divisions.filter(
+    (d) => d.unit_id != unit.unit_id && utils.unitsOverlap(unit, d, axisType, tolerance)
+  );
+  const u_pos = utils.getUnitHeightRange(unit, axisType);
+  const bottomOverlap = overlappingUnits.some((d) => {
+    const d_pos = utils.getUnitHeightRange(d, axisType);
+    return d_pos[0] < u_pos[0] + dt;
+  });
+  let column = 0;
+  if (overlappingUnits.length == 1) {
+    column = 1;
+  }
+  return {
+    ...unit,
+    bottomOverlap,
+    column: unit.column ?? column,
+    overlappingUnits: overlappingUnits.map((d) => d.unit_id)
+  };
+}
+function groupUnitsIntoSectionsBySectionID(units, axisType = columnComponents.ColumnAxisType.AGE) {
+  let groups = Array.from(d3Array.group(units, (d) => d.section_id));
+  const unitComparator = utils.createUnitSorter(axisType);
+  const groups1 = groups.map(([section_id, sectionUnits]) => {
+    const [b_age, t_age] = getSectionAgeRange(sectionUnits);
+    const [b_pos, t_pos] = getSectionPosRange(sectionUnits, axisType);
+    sectionUnits.sort(unitComparator);
+    return { section_id, t_age, b_age, b_pos, t_pos, units: sectionUnits };
+  });
+  const compareSections = utils.createUnitSorter(axisType);
+  groups1.sort(compareSections);
+  return groups1;
+}
+function groupUnitsIntoSectionsByOverlap(units, axisType = columnComponents.ColumnAxisType.AGE) {
+  const sectionList = [];
+  for (const unit of units) {
+    const heightRange = utils.getUnitHeightRange(unit, axisType);
+    let section = sectionList.find(
+      (s) => stratigraphyUtils.compareAgeRanges(heightRange, s.heightRange) !== stratigraphyUtils.AgeRangeRelationship.Disjoint
+    );
+    if (section == null) {
+      sectionList.push({
+        heightRange,
+        units: [unit]
+      });
+    } else {
+      section.units.push(unit);
+      if (axisType == columnComponents.ColumnAxisType.DEPTH || axisType == columnComponents.ColumnAxisType.AGE) {
+        section.heightRange = [
+          Math.max(section.heightRange[0], heightRange[0]),
+          Math.min(section.heightRange[1], heightRange[1])
+        ];
+      } else {
+        section.heightRange = [
+          Math.min(section.heightRange[0], heightRange[0]),
+          Math.max(section.heightRange[1], heightRange[1])
+        ];
+      }
+    }
+  }
+  return sectionList.map((section, i) => {
+    const [b_age, t_age] = getSectionAgeRange(section.units);
+    const [b_pos, t_pos] = getSectionPosRange(section.units, axisType);
+    return {
+      // Negative section IDs are used to indicate that these are synthetic sections
+      section_id: -i,
+      t_age,
+      b_age,
+      t_pos,
+      b_pos,
+      units: section.units
+    };
+  });
+}
+function getSectionPosRange(units, axisType) {
+  const t_positions = units.map((d) => {
+    switch (axisType) {
+      case columnComponents.ColumnAxisType.AGE:
+        return d.t_age;
+      case columnComponents.ColumnAxisType.DEPTH:
+      case columnComponents.ColumnAxisType.HEIGHT:
+      case columnComponents.ColumnAxisType.ORDINAL:
+        return d.t_pos;
+      default:
+        throw new Error(`Unknown axis type: ${axisType}`);
+    }
+  });
+  const b_positions = units.map((d) => {
+    switch (axisType) {
+      case columnComponents.ColumnAxisType.AGE:
+        return d.b_age;
+      case columnComponents.ColumnAxisType.DEPTH:
+      case columnComponents.ColumnAxisType.HEIGHT:
+      case columnComponents.ColumnAxisType.ORDINAL:
+        return d.b_pos;
+      default:
+        throw new Error(`Unknown axis type: ${axisType}`);
+    }
+  });
+  if (axisType == columnComponents.ColumnAxisType.AGE || axisType == columnComponents.ColumnAxisType.DEPTH) {
+    return [Math.max(...b_positions), Math.min(...t_positions)];
+  } else {
+    return [Math.min(...b_positions), Math.max(...t_positions)];
+  }
+}
+function getSectionAgeRange(units) {
+  return getSectionPosRange(units, columnComponents.ColumnAxisType.AGE);
+}
+function mergeOverlappingSections(sections) {
+  const [firstSection, ...rest] = sections;
+  const newSections = [firstSection];
+  for (const section of rest) {
+    const lastSection = newSections[newSections.length - 1];
+    if (lastSection.b_age < section.t_age || lastSection.t_age > section.b_age) {
+      newSections.push(section);
+      continue;
+    }
+    lastSection.section_id = [
+      ...utils.ensureArray(lastSection.section_id),
+      ...utils.ensureArray(section.section_id)
+    ];
+    lastSection.units.push(...section.units);
+    lastSection.b_age = Math.max(lastSection.b_age, section.b_age);
+    lastSection.t_age = Math.min(lastSection.t_age, section.t_age);
+  }
+  return newSections;
+}
+function preprocessSectionUnit(unit) {
+  let b_pos = unit.b_pos;
+  let t_pos = unit.t_pos;
+  let unit_name = unit.unit_name;
+  const match = unit.unit_name.match(/^(\d+(\.\d+)?)-(\d+(\.\d+)?): (.+)/);
+  if (match) {
+    t_pos ??= utils.ensureRealFloat(match[1]);
+    b_pos ??= utils.ensureRealFloat(match[3]);
+    unit_name = match[5];
+  }
+  return {
+    ...unit,
+    b_pos: utils.ensureRealFloat(b_pos),
+    t_pos: utils.ensureRealFloat(t_pos),
+    unit_name
+  };
+}
+exports.getSectionAgeRange = getSectionAgeRange;
+exports.getSectionPosRange = getSectionPosRange;
+exports.groupUnitsIntoSectionsByOverlap = groupUnitsIntoSectionsByOverlap;
+exports.groupUnitsIntoSectionsBySectionID = groupUnitsIntoSectionsBySectionID;
+exports.mergeOverlappingSections = mergeOverlappingSections;
+exports.preprocessSectionUnit = preprocessSectionUnit;
+exports.preprocessUnits = preprocessUnits;
+//# sourceMappingURL=helpers.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.cjs","sources":["../../src/prepare-units/helpers.ts"],"sourcesContent":["import type { BaseUnit, UnitLong } from \"@macrostrat/api-types\";\nimport { group } from \"d3-array\";\nimport { ColumnAxisType } from \"@macrostrat/column-components\";\nimport {\n  createUnitSorter,\n  ensureArray,\n  ensureRealFloat,\n  getUnitHeightRange,\n  unitsOverlap,\n} from \"./utils\";\nimport {\n  AgeRangeRelationship,\n  compareAgeRanges,\n} from \"@macrostrat/stratigraphy-utils\";\nimport type { ExtUnit, SectionInfo, StratigraphicPackage } from \"./types\";\n\nconst dt = 0.001;\n\nexport function preprocessUnits<T extends UnitLong = UnitLong>(\n  section: SectionInfo<T>,\n  axisType: ColumnAxisType = ColumnAxisType.AGE,\n): ExtUnit[] {\n  /** Preprocess units to add overlapping units and columns. */\n  let units = section.units;\n\n  let divisions = units.map((...args) => extendDivision(...args, axisType));\n  for (let d of divisions) {\n    const overlappingUnits = divisions.filter((u) =>\n      d.overlappingUnits.includes(u.unit_id),\n    );\n\n    // Overlapping columns\n    const columns = overlappingUnits.map((d) => d.column);\n\n    if (columns.includes(d.column)) {\n      let col = 0;\n      // Go through columns to find a better index\n      while (columns.includes(col)) {\n        col++;\n      }\n      d.column ??= col;\n    }\n\n    // If unit overlaps the edges of a section, set the clip positions\n    const [b_pos, t_pos] = getUnitHeightRange(d, axisType);\n    if (axisType == ColumnAxisType.AGE) {\n      if (b_pos > section.b_age) {\n        d.b_clip_pos = section.b_age;\n      }\n      if (t_pos < section.t_age) {\n        d.t_clip_pos = section.t_age;\n      }\n    }\n    if (axisType == ColumnAxisType.DEPTH) {\n      if (b_pos > section.b_pos) {\n        d.b_clip_pos = section.b_pos;\n      }\n      if (t_pos < section.t_pos) {\n        d.t_clip_pos = section.t_pos;\n      }\n    }\n    // if (axisType == ColumnAxisType.HEIGHT) {\n    //   if (b_pos < section.b_pos) {\n    //     d.b_clip_pos = section.b_pos;\n    //   }\n    //   if (t_pos > section.t_pos) {\n    //     d.t_clip_pos = section.t_pos;\n    //   }\n    // }\n  }\n\n  return divisions;\n}\n\nfunction extendDivision(\n  unit: UnitLong,\n  i: number,\n  divisions: UnitLong[],\n  axisType: ColumnAxisType = ColumnAxisType.AGE,\n): ExtUnit {\n  // TODO: make this configurable\n  let tolerance = 0.001; // 1 kyr tolerance for age columns\n  if (axisType != ColumnAxisType.AGE) {\n    tolerance = 0.01; // 1cm tolerance for height/depth columns\n  }\n\n  const overlappingUnits = divisions.filter(\n    (d) =>\n      d.unit_id != unit.unit_id && unitsOverlap(unit, d, axisType, tolerance),\n  );\n  const u_pos = getUnitHeightRange(unit, axisType);\n  const bottomOverlap = overlappingUnits.some((d) => {\n    const d_pos = getUnitHeightRange(d, axisType);\n    // Check if the unit is below the current unit\n    return d_pos[0] < u_pos[0] + dt;\n  });\n  let column = 0;\n  if (overlappingUnits.length == 1) {\n    column = 1;\n  }\n\n  return {\n    ...unit,\n    bottomOverlap,\n    column: unit.column ?? column,\n    overlappingUnits: overlappingUnits.map((d) => d.unit_id),\n  };\n}\n\nexport function groupUnitsIntoSectionsBySectionID<T extends UnitLong>(\n  units: T[],\n  axisType: ColumnAxisType = ColumnAxisType.AGE,\n): SectionInfo<T>[] {\n  /** Group units into sections by section_id.\n   * This works for large-scale Macrostrat columns, where units are grouped by section_id.\n   * */\n  let groups = Array.from(group(units, (d) => d.section_id));\n  const unitComparator = createUnitSorter(axisType);\n\n  const groups1 = groups.map(([section_id, sectionUnits]) => {\n    const [b_age, t_age] = getSectionAgeRange(sectionUnits);\n    const [b_pos, t_pos] = getSectionPosRange(sectionUnits, axisType);\n\n    // sort units by position\n    sectionUnits.sort(unitComparator);\n    return { section_id, t_age, b_age, b_pos, t_pos, units: sectionUnits };\n  });\n  // Sort sections by increasing top age, then increasing bottom age.\n  // Sections have no relative ordinal position other than age...\n  const compareSections = createUnitSorter(axisType) as (\n    a: StratigraphicPackage,\n    b: StratigraphicPackage,\n  ) => number;\n  groups1.sort(compareSections);\n  return groups1;\n}\n\ninterface WorkingSection {\n  units: UnitLong[];\n  // Position or age\n  heightRange?: [number, number];\n}\n\nexport function groupUnitsIntoSectionsByOverlap<T extends UnitLong>(\n  units: T[],\n  axisType: ColumnAxisType = ColumnAxisType.AGE,\n): SectionInfo<T>[] {\n  /** Group units into sections by overlap.\n   * This creates \"synthetic\" sections that correspond to packages bound by scale gaps.\n   * This is most useful in the height and depth domains, where gaps (e.g., missing core) are\n   * common.\n   * */\n  // Start with each unit as its own \"section\", and progressively merge...\n  const sectionList: WorkingSection[] = [];\n  for (const unit of units) {\n    // Check if the unit overlaps with any existing section\n    const heightRange = getUnitHeightRange(unit, axisType);\n    let section: WorkingSection | undefined = sectionList.find(\n      (s) =>\n        compareAgeRanges(heightRange, s.heightRange) !==\n        AgeRangeRelationship.Disjoint,\n    );\n    if (section == null) {\n      // No overlap, create a new section\n      sectionList.push({\n        heightRange,\n        units: [unit],\n      });\n    } else {\n      // Overlap, merge the unit into the section\n      section.units.push(unit);\n      // Update the height range\n      if (axisType == ColumnAxisType.DEPTH || axisType == ColumnAxisType.AGE) {\n        section.heightRange = [\n          Math.max(section.heightRange[0], heightRange[0]),\n          Math.min(section.heightRange[1], heightRange[1]),\n        ];\n      } else {\n        section.heightRange = [\n          Math.min(section.heightRange[0], heightRange[0]),\n          Math.max(section.heightRange[1], heightRange[1]),\n        ];\n      }\n    }\n  }\n  // We should have a section for each unit, now we can convert to SectionInfo\n  // Ages have to be really actually ages, not heights\n\n  return sectionList.map((section, i) => {\n    const [b_age, t_age] = getSectionAgeRange(section.units);\n    const [b_pos, t_pos] = getSectionPosRange(section.units, axisType);\n    return {\n      // Negative section IDs are used to indicate that these are synthetic sections\n      section_id: -i,\n      t_age,\n      b_age,\n      t_pos,\n      b_pos,\n      units: section.units as T[],\n    };\n  });\n}\n\nexport function getSectionPosRange(\n  units: BaseUnit[],\n  axisType: ColumnAxisType,\n): [number, number] {\n  /** Get the overall position range of a set of units. */\n  const t_positions = units.map((d) => {\n    switch (axisType) {\n      case ColumnAxisType.AGE:\n        return d.t_age;\n      case ColumnAxisType.DEPTH:\n      case ColumnAxisType.HEIGHT:\n      case ColumnAxisType.ORDINAL:\n        return d.t_pos;\n      default:\n        throw new Error(`Unknown axis type: ${axisType}`);\n    }\n  });\n  const b_positions = units.map((d) => {\n    switch (axisType) {\n      case ColumnAxisType.AGE:\n        return d.b_age;\n      case ColumnAxisType.DEPTH:\n      case ColumnAxisType.HEIGHT:\n      case ColumnAxisType.ORDINAL:\n        return d.b_pos;\n      default:\n        throw new Error(`Unknown axis type: ${axisType}`);\n    }\n  });\n  if (axisType == ColumnAxisType.AGE || axisType == ColumnAxisType.DEPTH) {\n    return [Math.max(...b_positions), Math.min(...t_positions)];\n  } else {\n    return [Math.min(...b_positions), Math.max(...t_positions)];\n  }\n}\n\nexport function getSectionAgeRange(units: BaseUnit[]): [number, number] {\n  /** Get the overall age range of a set of units. */\n  return getSectionPosRange(units, ColumnAxisType.AGE);\n}\n\nexport function mergeOverlappingSections<T extends UnitLong>(\n  sections: SectionInfo<T>[],\n): SectionInfo<T>[] {\n  /** Columns can have sections that overlap in time. Here, we merge overlapping\n   * sections into a single section to correctly render gap-bound packages.\n   */\n  const [firstSection, ...rest] = sections;\n  const newSections = [firstSection];\n  for (const section of rest) {\n    const lastSection = newSections[newSections.length - 1];\n    if (\n      lastSection.b_age < section.t_age ||\n      lastSection.t_age > section.b_age\n    ) {\n      // No overlap, add the section as normal\n      newSections.push(section);\n      continue;\n    }\n\n    // Overlap, merge the sections\n    lastSection.section_id = [\n      ...ensureArray(lastSection.section_id),\n      ...ensureArray(section.section_id),\n    ];\n    lastSection.units.push(...section.units);\n    lastSection.b_age = Math.max(lastSection.b_age, section.b_age);\n    lastSection.t_age = Math.min(lastSection.t_age, section.t_age);\n  }\n  return newSections;\n}\n\nexport function preprocessSectionUnit(unit: UnitLong): UnitLong {\n  /** Preprocess a single unit for a \"section\" column type.\n   * This mostly handles vagaries of eODP-style columns.\n   * */\n\n  let b_pos = unit.b_pos;\n  let t_pos = unit.t_pos;\n\n  let unit_name = unit.unit_name;\n\n  // eODP columns sometimes have overlapping core sections, which are encoded in the name field\n  // Match eODP section names\n  const match = unit.unit_name.match(/^(\\d+(\\.\\d+)?)-(\\d+(\\.\\d+)?): (.+)/);\n\n  if (match) {\n    // These values should already be set if we've used the show_positions flag\n    t_pos ??= ensureRealFloat(match[1]);\n    b_pos ??= ensureRealFloat(match[3]);\n    unit_name = match[5];\n  }\n\n  return {\n    ...unit,\n    b_pos: ensureRealFloat(b_pos),\n    t_pos: ensureRealFloat(t_pos),\n    unit_name,\n  };\n}\n"],"names":["ColumnAxisType","d","getUnitHeightRange","unitsOverlap","group","createUnitSorter","compareAgeRanges","AgeRangeRelationship","ensureArray","ensureRealFloat"],"mappings":"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"}

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

@@ -0,0 +1,10 @@
+import { BaseUnit, UnitLong } from '@macrostrat/api-types';
+import { ColumnAxisType } from '@macrostrat/column-components';
+import { ExtUnit, SectionInfo } from './types';
+export declare function preprocessUnits<T extends UnitLong = UnitLong>(section: SectionInfo<T>, axisType?: ColumnAxisType): ExtUnit[];
+export declare function groupUnitsIntoSectionsBySectionID<T extends UnitLong>(units: T[], axisType?: ColumnAxisType): SectionInfo<T>[];
+export declare function groupUnitsIntoSectionsByOverlap<T extends UnitLong>(units: T[], axisType?: ColumnAxisType): SectionInfo<T>[];
+export declare function getSectionPosRange(units: BaseUnit[], axisType: ColumnAxisType): [number, number];
+export declare function getSectionAgeRange(units: BaseUnit[]): [number, number];
+export declare function mergeOverlappingSections<T extends UnitLong>(sections: SectionInfo<T>[]): SectionInfo<T>[];
+export declare function preprocessSectionUnit(unit: UnitLong): UnitLong;

package/dist/prepare-units/helpers.js

@@ -0,0 +1,198 @@
+import { group } from "d3-array";
+import { ColumnAxisType } from "@macrostrat/column-components";
+import { getUnitHeightRange, ensureRealFloat, ensureArray, unitsOverlap, createUnitSorter } from "./utils.js";
+import { compareAgeRanges, AgeRangeRelationship } from "@macrostrat/stratigraphy-utils";
+const dt = 1e-3;
+function preprocessUnits(section, axisType = ColumnAxisType.AGE) {
+  let units = section.units;
+  let divisions = units.map((...args) => extendDivision(...args, axisType));
+  for (let d of divisions) {
+    const overlappingUnits = divisions.filter(
+      (u) => d.overlappingUnits.includes(u.unit_id)
+    );
+    const columns = overlappingUnits.map((d2) => d2.column);
+    if (columns.includes(d.column)) {
+      let col = 0;
+      while (columns.includes(col)) {
+        col++;
+      }
+      d.column ??= col;
+    }
+    const [b_pos, t_pos] = getUnitHeightRange(d, axisType);
+    if (axisType == ColumnAxisType.AGE) {
+      if (b_pos > section.b_age) {
+        d.b_clip_pos = section.b_age;
+      }
+      if (t_pos < section.t_age) {
+        d.t_clip_pos = section.t_age;
+      }
+    }
+    if (axisType == ColumnAxisType.DEPTH) {
+      if (b_pos > section.b_pos) {
+        d.b_clip_pos = section.b_pos;
+      }
+      if (t_pos < section.t_pos) {
+        d.t_clip_pos = section.t_pos;
+      }
+    }
+  }
+  return divisions;
+}
+function extendDivision(unit, i, divisions, axisType = ColumnAxisType.AGE) {
+  let tolerance = 1e-3;
+  if (axisType != ColumnAxisType.AGE) {
+    tolerance = 0.01;
+  }
+  const overlappingUnits = divisions.filter(
+    (d) => d.unit_id != unit.unit_id && unitsOverlap(unit, d, axisType, tolerance)
+  );
+  const u_pos = getUnitHeightRange(unit, axisType);
+  const bottomOverlap = overlappingUnits.some((d) => {
+    const d_pos = getUnitHeightRange(d, axisType);
+    return d_pos[0] < u_pos[0] + dt;
+  });
+  let column = 0;
+  if (overlappingUnits.length == 1) {
+    column = 1;
+  }
+  return {
+    ...unit,
+    bottomOverlap,
+    column: unit.column ?? column,
+    overlappingUnits: overlappingUnits.map((d) => d.unit_id)
+  };
+}
+function groupUnitsIntoSectionsBySectionID(units, axisType = ColumnAxisType.AGE) {
+  let groups = Array.from(group(units, (d) => d.section_id));
+  const unitComparator = createUnitSorter(axisType);
+  const groups1 = groups.map(([section_id, sectionUnits]) => {
+    const [b_age, t_age] = getSectionAgeRange(sectionUnits);
+    const [b_pos, t_pos] = getSectionPosRange(sectionUnits, axisType);
+    sectionUnits.sort(unitComparator);
+    return { section_id, t_age, b_age, b_pos, t_pos, units: sectionUnits };
+  });
+  const compareSections = createUnitSorter(axisType);
+  groups1.sort(compareSections);
+  return groups1;
+}
+function groupUnitsIntoSectionsByOverlap(units, axisType = ColumnAxisType.AGE) {
+  const sectionList = [];
+  for (const unit of units) {
+    const heightRange = getUnitHeightRange(unit, axisType);
+    let section = sectionList.find(
+      (s) => compareAgeRanges(heightRange, s.heightRange) !== AgeRangeRelationship.Disjoint
+    );
+    if (section == null) {
+      sectionList.push({
+        heightRange,
+        units: [unit]
+      });
+    } else {
+      section.units.push(unit);
+      if (axisType == ColumnAxisType.DEPTH || axisType == ColumnAxisType.AGE) {
+        section.heightRange = [
+          Math.max(section.heightRange[0], heightRange[0]),
+          Math.min(section.heightRange[1], heightRange[1])
+        ];
+      } else {
+        section.heightRange = [
+          Math.min(section.heightRange[0], heightRange[0]),
+          Math.max(section.heightRange[1], heightRange[1])
+        ];
+      }
+    }
+  }
+  return sectionList.map((section, i) => {
+    const [b_age, t_age] = getSectionAgeRange(section.units);
+    const [b_pos, t_pos] = getSectionPosRange(section.units, axisType);
+    return {
+      // Negative section IDs are used to indicate that these are synthetic sections
+      section_id: -i,
+      t_age,
+      b_age,
+      t_pos,
+      b_pos,
+      units: section.units
+    };
+  });
+}
+function getSectionPosRange(units, axisType) {
+  const t_positions = units.map((d) => {
+    switch (axisType) {
+      case ColumnAxisType.AGE:
+        return d.t_age;
+      case ColumnAxisType.DEPTH:
+      case ColumnAxisType.HEIGHT:
+      case ColumnAxisType.ORDINAL:
+        return d.t_pos;
+      default:
+        throw new Error(`Unknown axis type: ${axisType}`);
+    }
+  });
+  const b_positions = units.map((d) => {
+    switch (axisType) {
+      case ColumnAxisType.AGE:
+        return d.b_age;
+      case ColumnAxisType.DEPTH:
+      case ColumnAxisType.HEIGHT:
+      case ColumnAxisType.ORDINAL:
+        return d.b_pos;
+      default:
+        throw new Error(`Unknown axis type: ${axisType}`);
+    }
+  });
+  if (axisType == ColumnAxisType.AGE || axisType == ColumnAxisType.DEPTH) {
+    return [Math.max(...b_positions), Math.min(...t_positions)];
+  } else {
+    return [Math.min(...b_positions), Math.max(...t_positions)];
+  }
+}
+function getSectionAgeRange(units) {
+  return getSectionPosRange(units, ColumnAxisType.AGE);
+}
+function mergeOverlappingSections(sections) {
+  const [firstSection, ...rest] = sections;
+  const newSections = [firstSection];
+  for (const section of rest) {
+    const lastSection = newSections[newSections.length - 1];
+    if (lastSection.b_age < section.t_age || lastSection.t_age > section.b_age) {
+      newSections.push(section);
+      continue;
+    }
+    lastSection.section_id = [
+      ...ensureArray(lastSection.section_id),
+      ...ensureArray(section.section_id)
+    ];
+    lastSection.units.push(...section.units);
+    lastSection.b_age = Math.max(lastSection.b_age, section.b_age);
+    lastSection.t_age = Math.min(lastSection.t_age, section.t_age);
+  }
+  return newSections;
+}
+function preprocessSectionUnit(unit) {
+  let b_pos = unit.b_pos;
+  let t_pos = unit.t_pos;
+  let unit_name = unit.unit_name;
+  const match = unit.unit_name.match(/^(\d+(\.\d+)?)-(\d+(\.\d+)?): (.+)/);
+  if (match) {
+    t_pos ??= ensureRealFloat(match[1]);
+    b_pos ??= ensureRealFloat(match[3]);
+    unit_name = match[5];
+  }
+  return {
+    ...unit,
+    b_pos: ensureRealFloat(b_pos),
+    t_pos: ensureRealFloat(t_pos),
+    unit_name
+  };
+}
+export {
+  getSectionAgeRange,
+  getSectionPosRange,
+  groupUnitsIntoSectionsByOverlap,
+  groupUnitsIntoSectionsBySectionID,
+  mergeOverlappingSections,
+  preprocessSectionUnit,
+  preprocessUnits
+};
+//# sourceMappingURL=helpers.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","sources":["../../src/prepare-units/helpers.ts"],"sourcesContent":["import type { BaseUnit, UnitLong } from \"@macrostrat/api-types\";\nimport { group } from \"d3-array\";\nimport { ColumnAxisType } from \"@macrostrat/column-components\";\nimport {\n  createUnitSorter,\n  ensureArray,\n  ensureRealFloat,\n  getUnitHeightRange,\n  unitsOverlap,\n} from \"./utils\";\nimport {\n  AgeRangeRelationship,\n  compareAgeRanges,\n} from \"@macrostrat/stratigraphy-utils\";\nimport type { ExtUnit, SectionInfo, StratigraphicPackage } from \"./types\";\n\nconst dt = 0.001;\n\nexport function preprocessUnits<T extends UnitLong = UnitLong>(\n  section: SectionInfo<T>,\n  axisType: ColumnAxisType = ColumnAxisType.AGE,\n): ExtUnit[] {\n  /** Preprocess units to add overlapping units and columns. */\n  let units = section.units;\n\n  let divisions = units.map((...args) => extendDivision(...args, axisType));\n  for (let d of divisions) {\n    const overlappingUnits = divisions.filter((u) =>\n      d.overlappingUnits.includes(u.unit_id),\n    );\n\n    // Overlapping columns\n    const columns = overlappingUnits.map((d) => d.column);\n\n    if (columns.includes(d.column)) {\n      let col = 0;\n      // Go through columns to find a better index\n      while (columns.includes(col)) {\n        col++;\n      }\n      d.column ??= col;\n    }\n\n    // If unit overlaps the edges of a section, set the clip positions\n    const [b_pos, t_pos] = getUnitHeightRange(d, axisType);\n    if (axisType == ColumnAxisType.AGE) {\n      if (b_pos > section.b_age) {\n        d.b_clip_pos = section.b_age;\n      }\n      if (t_pos < section.t_age) {\n        d.t_clip_pos = section.t_age;\n      }\n    }\n    if (axisType == ColumnAxisType.DEPTH) {\n      if (b_pos > section.b_pos) {\n        d.b_clip_pos = section.b_pos;\n      }\n      if (t_pos < section.t_pos) {\n        d.t_clip_pos = section.t_pos;\n      }\n    }\n    // if (axisType == ColumnAxisType.HEIGHT) {\n    //   if (b_pos < section.b_pos) {\n    //     d.b_clip_pos = section.b_pos;\n    //   }\n    //   if (t_pos > section.t_pos) {\n    //     d.t_clip_pos = section.t_pos;\n    //   }\n    // }\n  }\n\n  return divisions;\n}\n\nfunction extendDivision(\n  unit: UnitLong,\n  i: number,\n  divisions: UnitLong[],\n  axisType: ColumnAxisType = ColumnAxisType.AGE,\n): ExtUnit {\n  // TODO: make this configurable\n  let tolerance = 0.001; // 1 kyr tolerance for age columns\n  if (axisType != ColumnAxisType.AGE) {\n    tolerance = 0.01; // 1cm tolerance for height/depth columns\n  }\n\n  const overlappingUnits = divisions.filter(\n    (d) =>\n      d.unit_id != unit.unit_id && unitsOverlap(unit, d, axisType, tolerance),\n  );\n  const u_pos = getUnitHeightRange(unit, axisType);\n  const bottomOverlap = overlappingUnits.some((d) => {\n    const d_pos = getUnitHeightRange(d, axisType);\n    // Check if the unit is below the current unit\n    return d_pos[0] < u_pos[0] + dt;\n  });\n  let column = 0;\n  if (overlappingUnits.length == 1) {\n    column = 1;\n  }\n\n  return {\n    ...unit,\n    bottomOverlap,\n    column: unit.column ?? column,\n    overlappingUnits: overlappingUnits.map((d) => d.unit_id),\n  };\n}\n\nexport function groupUnitsIntoSectionsBySectionID<T extends UnitLong>(\n  units: T[],\n  axisType: ColumnAxisType = ColumnAxisType.AGE,\n): SectionInfo<T>[] {\n  /** Group units into sections by section_id.\n   * This works for large-scale Macrostrat columns, where units are grouped by section_id.\n   * */\n  let groups = Array.from(group(units, (d) => d.section_id));\n  const unitComparator = createUnitSorter(axisType);\n\n  const groups1 = groups.map(([section_id, sectionUnits]) => {\n    const [b_age, t_age] = getSectionAgeRange(sectionUnits);\n    const [b_pos, t_pos] = getSectionPosRange(sectionUnits, axisType);\n\n    // sort units by position\n    sectionUnits.sort(unitComparator);\n    return { section_id, t_age, b_age, b_pos, t_pos, units: sectionUnits };\n  });\n  // Sort sections by increasing top age, then increasing bottom age.\n  // Sections have no relative ordinal position other than age...\n  const compareSections = createUnitSorter(axisType) as (\n    a: StratigraphicPackage,\n    b: StratigraphicPackage,\n  ) => number;\n  groups1.sort(compareSections);\n  return groups1;\n}\n\ninterface WorkingSection {\n  units: UnitLong[];\n  // Position or age\n  heightRange?: [number, number];\n}\n\nexport function groupUnitsIntoSectionsByOverlap<T extends UnitLong>(\n  units: T[],\n  axisType: ColumnAxisType = ColumnAxisType.AGE,\n): SectionInfo<T>[] {\n  /** Group units into sections by overlap.\n   * This creates \"synthetic\" sections that correspond to packages bound by scale gaps.\n   * This is most useful in the height and depth domains, where gaps (e.g., missing core) are\n   * common.\n   * */\n  // Start with each unit as its own \"section\", and progressively merge...\n  const sectionList: WorkingSection[] = [];\n  for (const unit of units) {\n    // Check if the unit overlaps with any existing section\n    const heightRange = getUnitHeightRange(unit, axisType);\n    let section: WorkingSection | undefined = sectionList.find(\n      (s) =>\n        compareAgeRanges(heightRange, s.heightRange) !==\n        AgeRangeRelationship.Disjoint,\n    );\n    if (section == null) {\n      // No overlap, create a new section\n      sectionList.push({\n        heightRange,\n        units: [unit],\n      });\n    } else {\n      // Overlap, merge the unit into the section\n      section.units.push(unit);\n      // Update the height range\n      if (axisType == ColumnAxisType.DEPTH || axisType == ColumnAxisType.AGE) {\n        section.heightRange = [\n          Math.max(section.heightRange[0], heightRange[0]),\n          Math.min(section.heightRange[1], heightRange[1]),\n        ];\n      } else {\n        section.heightRange = [\n          Math.min(section.heightRange[0], heightRange[0]),\n          Math.max(section.heightRange[1], heightRange[1]),\n        ];\n      }\n    }\n  }\n  // We should have a section for each unit, now we can convert to SectionInfo\n  // Ages have to be really actually ages, not heights\n\n  return sectionList.map((section, i) => {\n    const [b_age, t_age] = getSectionAgeRange(section.units);\n    const [b_pos, t_pos] = getSectionPosRange(section.units, axisType);\n    return {\n      // Negative section IDs are used to indicate that these are synthetic sections\n      section_id: -i,\n      t_age,\n      b_age,\n      t_pos,\n      b_pos,\n      units: section.units as T[],\n    };\n  });\n}\n\nexport function getSectionPosRange(\n  units: BaseUnit[],\n  axisType: ColumnAxisType,\n): [number, number] {\n  /** Get the overall position range of a set of units. */\n  const t_positions = units.map((d) => {\n    switch (axisType) {\n      case ColumnAxisType.AGE:\n        return d.t_age;\n      case ColumnAxisType.DEPTH:\n      case ColumnAxisType.HEIGHT:\n      case ColumnAxisType.ORDINAL:\n        return d.t_pos;\n      default:\n        throw new Error(`Unknown axis type: ${axisType}`);\n    }\n  });\n  const b_positions = units.map((d) => {\n    switch (axisType) {\n      case ColumnAxisType.AGE:\n        return d.b_age;\n      case ColumnAxisType.DEPTH:\n      case ColumnAxisType.HEIGHT:\n      case ColumnAxisType.ORDINAL:\n        return d.b_pos;\n      default:\n        throw new Error(`Unknown axis type: ${axisType}`);\n    }\n  });\n  if (axisType == ColumnAxisType.AGE || axisType == ColumnAxisType.DEPTH) {\n    return [Math.max(...b_positions), Math.min(...t_positions)];\n  } else {\n    return [Math.min(...b_positions), Math.max(...t_positions)];\n  }\n}\n\nexport function getSectionAgeRange(units: BaseUnit[]): [number, number] {\n  /** Get the overall age range of a set of units. */\n  return getSectionPosRange(units, ColumnAxisType.AGE);\n}\n\nexport function mergeOverlappingSections<T extends UnitLong>(\n  sections: SectionInfo<T>[],\n): SectionInfo<T>[] {\n  /** Columns can have sections that overlap in time. Here, we merge overlapping\n   * sections into a single section to correctly render gap-bound packages.\n   */\n  const [firstSection, ...rest] = sections;\n  const newSections = [firstSection];\n  for (const section of rest) {\n    const lastSection = newSections[newSections.length - 1];\n    if (\n      lastSection.b_age < section.t_age ||\n      lastSection.t_age > section.b_age\n    ) {\n      // No overlap, add the section as normal\n      newSections.push(section);\n      continue;\n    }\n\n    // Overlap, merge the sections\n    lastSection.section_id = [\n      ...ensureArray(lastSection.section_id),\n      ...ensureArray(section.section_id),\n    ];\n    lastSection.units.push(...section.units);\n    lastSection.b_age = Math.max(lastSection.b_age, section.b_age);\n    lastSection.t_age = Math.min(lastSection.t_age, section.t_age);\n  }\n  return newSections;\n}\n\nexport function preprocessSectionUnit(unit: UnitLong): UnitLong {\n  /** Preprocess a single unit for a \"section\" column type.\n   * This mostly handles vagaries of eODP-style columns.\n   * */\n\n  let b_pos = unit.b_pos;\n  let t_pos = unit.t_pos;\n\n  let unit_name = unit.unit_name;\n\n  // eODP columns sometimes have overlapping core sections, which are encoded in the name field\n  // Match eODP section names\n  const match = unit.unit_name.match(/^(\\d+(\\.\\d+)?)-(\\d+(\\.\\d+)?): (.+)/);\n\n  if (match) {\n    // These values should already be set if we've used the show_positions flag\n    t_pos ??= ensureRealFloat(match[1]);\n    b_pos ??= ensureRealFloat(match[3]);\n    unit_name = match[5];\n  }\n\n  return {\n    ...unit,\n    b_pos: ensureRealFloat(b_pos),\n    t_pos: ensureRealFloat(t_pos),\n    unit_name,\n  };\n}\n"],"names":["d"],"mappings":"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"}

package/dist/prepare-units/index.cjs

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const helpers = require("./helpers.cjs");
+const columnComponents = require("@macrostrat/column-components");
+const React = require("react");
+const compositeScale = require("./composite-scale.cjs");
+const utils = require("./utils.cjs");
+function usePreparedColumnUnits(data, options) {
+  return React.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 = utils.MergeSectionsMode.OVERLAPPING,
+    axisType,
+    unconformityHeight,
+    collapseSmallUnconformities = false,
+    hybridScale,
+    scale
+  } = options;
+  let _totalHeight = null;
+  if (scale != null) {
+    const domain = scale.domain();
+    if (axisType == columnComponents.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(helpers.preprocessSectionUnit);
+  units1 = units1.filter((d) => {
+    if (axisType == columnComponents.ColumnAxisType.AGE) {
+      return utils.agesOverlap(d, { t_age, b_age });
+    } else {
+      return utils.unitsOverlap(d, { t_pos, b_pos }, axisType);
+    }
+  });
+  let mergeMode = mergeSections;
+  let sections0;
+  if (mergeMode == utils.MergeSectionsMode.ALL) {
+    const [b_unit_pos, t_unit_pos] = helpers.getSectionPosRange(units1, axisType);
+    const [b_unit_age, t_unit_age] = helpers.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 == columnComponents.ColumnAxisType.AGE) {
+    sections0 = helpers.groupUnitsIntoSectionsBySectionID(units1, axisType);
+  } else {
+    sections0 = helpers.groupUnitsIntoSectionsByOverlap(units1, axisType);
+  }
+  for (let section of sections0) {
+    if (axisType == columnComponents.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 == columnComponents.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 == columnComponents.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 == utils.MergeSectionsMode.OVERLAPPING && axisType == columnComponents.ColumnAxisType.AGE) {
+    sections = helpers.mergeOverlappingSections(sections);
+  }
+  sections = sections.filter((d) => d != null);
+  let sectionsWithScales = compositeScale.computeSectionHeights(sections, options);
+  if (collapseSmallUnconformities && hybridScale == null) {
+    let threshold = unconformityHeight ?? 30;
+    if (typeof collapseSmallUnconformities == "number") {
+      threshold = collapseSmallUnconformities;
+    }
+    sectionsWithScales = compositeScale.collapseUnconformitiesByPixelHeight(
+      sectionsWithScales,
+      threshold,
+      options
+    );
+  }
+  let { totalHeight, sections: sections2 } = compositeScale.finalizeSectionHeights(
+    sectionsWithScales,
+    unconformityHeight
+  );
+  const sectionsOut = sections2.map((section) => {
+    return {
+      ...section,
+      units: helpers.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
+  };
+}
+exports.preprocessUnits = helpers.preprocessUnits;
+exports.MergeSectionsMode = utils.MergeSectionsMode;
+exports.agesOverlap = utils.agesOverlap;
+exports.createUnitSorter = utils.createUnitSorter;
+exports.ensureArray = utils.ensureArray;
+exports.ensureRealFloat = utils.ensureRealFloat;
+exports.getPositionWithinUnit = utils.getPositionWithinUnit;
+exports.getUnitHeightRange = utils.getUnitHeightRange;
+exports.unitsOverlap = utils.unitsOverlap;
+exports.prepareColumnUnits = prepareColumnUnits;
+exports.usePreparedColumnUnits = usePreparedColumnUnits;
+//# sourceMappingURL=index.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","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":["useMemo","MergeSectionsMode","ColumnAxisType","preprocessSectionUnit","agesOverlap","unitsOverlap","getSectionPosRange","getSectionAgeRange","groupUnitsIntoSectionsBySectionID","groupUnitsIntoSectionsByOverlap","mergeOverlappingSections","computeSectionHeights","collapseUnconformitiesByPixelHeight","finalizeSectionHeights","preprocessUnits","units"],"mappings":"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"}

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

@@ -0,0 +1,10 @@
+import { preprocessUnits } from './helpers';
+import { UnitLong } from '@macrostrat/api-types';
+import { CompositeColumnScale } from './composite-scale';
+import { PrepareColumnOptions, PreparedColumnData } from './utils';
+export * from './utils';
+export * from './types';
+export { preprocessUnits };
+export type { CompositeColumnScale };
+export declare function usePreparedColumnUnits(data: UnitLong[], options: PrepareColumnOptions): PreparedColumnData;
+export declare function prepareColumnUnits(units: UnitLong[], options: PrepareColumnOptions): PreparedColumnData;