@macrostrat/column-views 2.4.4 → 3.0.1

package/dist/notes.js

@@ -0,0 +1,41 @@
+import h from "@macrostrat/hyper";
+import { SVG, NotesColumn } from "@macrostrat/column-components";
+import { ColumnNotesProvider } from "./units/composite.js";
+import { useMacrostratColumnData, useCompositeScale } from "./data-provider/store.js";
+function ColumnNotes({
+  notes,
+  width = 200,
+  noteComponent,
+  paddingLeft = 60,
+  deltaConnectorAttachment,
+  focusedNoteComponent,
+  children
+}) {
+  const { totalHeight } = useMacrostratColumnData();
+  const scale = useCompositeScale();
+  return h(
+    ColumnNotesProvider,
+    {
+      scale,
+      totalHeight,
+      pixelScale: -1
+    },
+    [
+      h(SVG, { width, height: totalHeight, paddingH: 4 }, [
+        h(NotesColumn, {
+          width,
+          notes,
+          noteComponent,
+          paddingLeft,
+          deltaConnectorAttachment,
+          focusedNoteComponent
+        })
+      ]),
+      children
+    ]
+  );
+}
+export {
+  ColumnNotes
+};
+//# sourceMappingURL=notes.js.map

package/dist/notes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"notes.js","sources":["../src/notes.ts"],"sourcesContent":["import h from \"@macrostrat/hyper\";\n\nimport { ColumnNotesProvider } from \"./units\";\n\nimport { NotesColumn, SVG } from \"@macrostrat/column-components\";\nimport { useCompositeScale, useMacrostratColumnData } from \"./data-provider\";\nimport type { ComponentType, ReactNode } from \"react\";\n\ninterface ColumnNotesProps {\n  notes: any[];\n  width?: number;\n  noteComponent?: any;\n  paddingLeft?: number;\n  deltaConnectorAttachment?: number;\n  children?: ReactNode;\n  focusedNoteComponent?: ComponentType<any> | null;\n}\n\nexport function ColumnNotes({\n  notes,\n  width = 200,\n  noteComponent,\n  paddingLeft = 60,\n  deltaConnectorAttachment,\n  focusedNoteComponent,\n  children,\n}: ColumnNotesProps) {\n  const { totalHeight } = useMacrostratColumnData();\n  const scale = useCompositeScale();\n\n  return h(\n    ColumnNotesProvider,\n    {\n      scale,\n      totalHeight,\n      pixelScale: -1,\n    },\n    [\n      h(SVG, { width, height: totalHeight, paddingH: 4 }, [\n        h(NotesColumn, {\n          width,\n          notes,\n          noteComponent,\n          paddingLeft,\n          deltaConnectorAttachment,\n          focusedNoteComponent,\n        }),\n      ]),\n      children,\n    ],\n  );\n}\n"],"names":[],"mappings":";;;;AAkBO,SAAS,YAAY;AAAA,EAC1B;AAAA,EACA,QAAQ;AAAA,EACR;AAAA,EACA,cAAc;AAAA,EACd;AAAA,EACA;AAAA,EACA;AACF,GAAqB;AACnB,QAAM,EAAE,YAAA,IAAgB,wBAAA;AACxB,QAAM,QAAQ,kBAAA;AAEd,SAAO;AAAA,IACL;AAAA,IACA;AAAA,MACE;AAAA,MACA;AAAA,MACA,YAAY;AAAA,IAAA;AAAA,IAEd;AAAA,MACE,EAAE,KAAK,EAAE,OAAO,QAAQ,aAAa,UAAU,KAAK;AAAA,QAClD,EAAE,aAAa;AAAA,UACb;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,QAAA,CACD;AAAA,MAAA,CACF;AAAA,MACD;AAAA,IAAA;AAAA,EACF;AAEJ;"}

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

@@ -0,0 +1,284 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const columnComponents = require("@macrostrat/column-components");
+const utils = require("./utils.cjs");
+const d3Scale = require("d3-scale");
+const dynamicScales = require("./dynamic-scales.cjs");
+const types = require("./types.cjs");
+function buildCompositeScaleInfo(inputScales, unconformityHeight) {
+  let totalHeight = unconformityHeight / 2;
+  let lastSectionTopHeight = 0;
+  const packages2 = [];
+  for (const group of inputScales) {
+    const { domain, scale } = group;
+    const [b_age, t_age] = domain;
+    const key = `package-${b_age}-${t_age}`;
+    packages2.push({
+      ...createPackageScale(group, totalHeight),
+      key,
+      offset: totalHeight,
+      // Unconformity height above this particular section
+      paddingTop: totalHeight - lastSectionTopHeight
+    });
+    const pixelHeight = Math.abs(scale(b_age) - scale(t_age));
+    lastSectionTopHeight = totalHeight + pixelHeight;
+    totalHeight = lastSectionTopHeight + unconformityHeight;
+  }
+  totalHeight += unconformityHeight / 2;
+  return {
+    totalHeight,
+    sections: packages2
+  };
+}
+function finalizeSectionHeights(sections, unconformityHeight) {
+  const sectionScales = sections.map((d) => d.scaleInfo);
+  const { totalHeight, sections: packages } = buildCompositeScaleInfo(
+    sectionScales,
+    unconformityHeight
+  );
+  const sections1 = [];
+  for (const i in sections) {
+    const group = sections[i];
+    const scaleInfo = packages[i];
+    sections1.push({
+      ...group,
+      key: scaleInfo.key,
+      scaleInfo
+    });
+  }
+  return {
+    totalHeight,
+    sections: sections1
+  };
+}
+function computeSectionHeights(sections, opts) {
+  return sections.map((group) => {
+    return addScaleToSection(group, opts);
+  });
+}
+function addScaleToSection(group, opts) {
+  const { t_age, b_age, t_pos, b_pos, units } = group;
+  let _range = null;
+  if (opts.axisType == columnComponents.ColumnAxisType.AGE) {
+    _range = [b_age, t_age];
+  } else {
+    _range = [b_pos, t_pos];
+  }
+  const scaleInfo = buildSectionScale(units, {
+    ...opts,
+    domain: _range
+  });
+  return {
+    ...group,
+    scaleInfo
+  };
+}
+function buildSectionScale(data, opts) {
+  const {
+    targetUnitHeight = 20,
+    minPixelScale = 0.2,
+    axisType,
+    minSectionHeight,
+    scale,
+    hybridScale
+  } = opts;
+  const domain = opts.domain ?? findSectionHeightRange(data, axisType);
+  const dAge = Math.abs(domain[0] - domain[1]);
+  let _pixelScale = opts.pixelScale;
+  let pixelHeight;
+  if (hybridScale != null) {
+    if (hybridScale.type === types.HybridScaleType.EquidistantSurfaces) {
+      _pixelScale ??= targetUnitHeight;
+    }
+    return dynamicScales.buildHybridScale(hybridScale, data, domain, {
+      pixelOffset: 0,
+      pixelScale: _pixelScale
+    });
+  }
+  if (scale == null) {
+    if (_pixelScale == null) {
+      const avgAgeRange = findAverageUnitHeight(data, axisType);
+      _pixelScale = Math.max(targetUnitHeight / avgAgeRange, minPixelScale);
+    }
+    let height = dAge * _pixelScale;
+    const _minSectionHeight = minSectionHeight ?? targetUnitHeight ?? 0;
+    pixelHeight = Math.max(height, _minSectionHeight);
+    _pixelScale = pixelHeight / dAge;
+  } else {
+    pixelHeight = Math.abs(scale(domain[0]) - scale(domain[1]));
+  }
+  return createPackageScale(
+    { scale, domain, pixelHeight, pixelScale: _pixelScale },
+    0
+  );
+}
+function createPackageScale(def, offset = 0) {
+  const { domain, pixelScale, pixelHeight, scale, heightScale } = def;
+  if (scale == null && pixelScale == null) {
+    throw new Error("Either scale or pixelScale must be provided");
+  }
+  let _scale;
+  if (scale == null) {
+    _scale = d3Scale.scaleLinear().domain([domain[1], domain[0]]).range([offset, pixelHeight + offset]);
+  } else {
+    const domain0 = scale.domain();
+    const range0 = scale.range();
+    _scale = scale.copy().domain(domain0).range(range0.map((d) => d + offset));
+  }
+  _scale.clamp();
+  let _heightScale = null;
+  if (heightScale != null) {
+    const range0 = scale.range();
+    _heightScale = heightScale.copy().range(range0.map((d) => d + offset));
+    _heightScale.clamp();
+  }
+  return {
+    domain,
+    pixelScale,
+    pixelHeight,
+    scale: _scale,
+    // Internal details for hybrid scales. TODO: improve this
+    heightScale: _heightScale
+  };
+}
+function findSectionHeightRange(data, axisType) {
+  if (axisType == null) {
+    throw new Error("Axis type is not set");
+  }
+  if (axisType === columnComponents.ColumnAxisType.AGE) {
+    const t_age = Math.min(...data.map((d) => d.t_age));
+    const b_age = Math.max(...data.map((d) => d.b_age));
+    return [b_age, t_age];
+  } else if (axisType == columnComponents.ColumnAxisType.DEPTH || axisType == columnComponents.ColumnAxisType.ORDINAL) {
+    const t_pos = Math.min(...data.map((d) => d.t_pos));
+    const b_pos = Math.max(...data.map((d) => d.b_pos));
+    return [b_pos, t_pos];
+  } else if (axisType == columnComponents.ColumnAxisType.HEIGHT) {
+    const t_pos = Math.max(...data.map((d) => d.t_pos));
+    const b_pos = Math.min(...data.map((d) => d.b_pos));
+    return [b_pos, t_pos];
+  }
+}
+function findAverageUnitHeight(data, axisType) {
+  const unitHeights = data.map((d) => {
+    const [b_pos, t_pos] = utils.getUnitHeightRange(d, axisType);
+    return Math.abs(b_pos - t_pos);
+  });
+  return unitHeights.reduce((a, b) => a + b, 0) / unitHeights.length;
+}
+function createCompositeScale(sections, interpolateUnconformities = false) {
+  const scales = [];
+  let lastScale = null;
+  for (const section of sections) {
+    const _scale = section.scaleInfo.scale.copy().clamp(true);
+    scales.push(_scale);
+    if (lastScale != null && interpolateUnconformities) {
+      const lastDomain = lastScale.domain();
+      const lastRange = lastScale.range();
+      const currentDomain = _scale.domain();
+      const currentRange = _scale.range();
+      const interpScale = d3Scale.scaleLinear().domain([lastDomain[lastDomain.length - 1], currentDomain[0]]).range([lastRange[lastRange.length - 1], currentRange[0]]).clamp(true);
+      scales.push(interpScale);
+    }
+    lastScale = _scale;
+  }
+  const scale = (age) => {
+    for (const s of scales) {
+      const domain = s.domain();
+      if (domain[0] < domain[domain.length - 1] && age >= domain[0] && age <= domain[domain.length - 1]) {
+        return s(age);
+      } else if (age <= domain[0] && age >= domain[domain.length - 1]) {
+        return s(age);
+      }
+    }
+    return null;
+  };
+  scale.copy = () => {
+    return createCompositeScale(sections, interpolateUnconformities);
+  };
+  scale.domain = () => {
+    const vals = sections.flatMap((d) => d.scaleInfo.domain);
+    if (vals[0] < vals[vals.length - 1]) {
+      return [Math.min(...vals), Math.max(...vals)];
+    }
+    return [Math.max(...vals), Math.min(...vals)];
+  };
+  scale.invert = (pixelHeight) => {
+    for (const scale2 of scales) {
+      const range = scale2.range();
+      if (pixelHeight > Math.min(...range) && pixelHeight <= Math.max(...range)) {
+        console.log("Inverting scale at pixel height", pixelHeight);
+        return scale2.invert(pixelHeight);
+      }
+    }
+    return null;
+  };
+  scale.clamp = (clamp) => {
+    for (const s of scales) {
+      s.clamp(clamp);
+    }
+  };
+  return scale;
+}
+function collapseUnconformitiesByPixelHeight(sections, threshold, opts) {
+  const newSections = [];
+  let currentSection = null;
+  for (const nextSection of sections) {
+    if (currentSection == null) {
+      currentSection = nextSection;
+      continue;
+    }
+    let heights;
+    let pxHeights;
+    if (opts.axisType !== columnComponents.ColumnAxisType.AGE) {
+      heights = [nextSection.t_pos, currentSection.b_pos];
+    } else {
+      heights = [nextSection.t_age, currentSection.b_age];
+    }
+    const _diff = (vals) => {
+      return Math.abs(vals[0] - vals[1]);
+    };
+    pxHeights = [
+      _diff(heights.map(nextSection.scaleInfo.scale)),
+      _diff(heights.map(currentSection.scaleInfo.scale))
+    ];
+    const pxHeight = Math.min(...pxHeights);
+    if (pxHeight < threshold) {
+      let t_pos;
+      let b_pos;
+      if (opts.axisType == columnComponents.ColumnAxisType.AGE || opts.axisType == columnComponents.ColumnAxisType.DEPTH) {
+        t_pos = Math.min(currentSection.t_pos, nextSection.t_pos);
+        b_pos = Math.max(currentSection.b_pos, nextSection.b_pos);
+      } else {
+        t_pos = Math.max(currentSection.t_pos, nextSection.t_pos);
+        b_pos = Math.min(currentSection.b_pos, nextSection.b_pos);
+      }
+      const compositeSection0 = {
+        units: [...currentSection.units, ...nextSection.units],
+        section_id: [
+          ...utils.ensureArray(currentSection.section_id),
+          ...utils.ensureArray(nextSection.section_id)
+        ],
+        t_age: Math.min(currentSection.t_age, nextSection.t_age),
+        b_age: Math.max(currentSection.b_age, nextSection.b_age),
+        t_pos,
+        b_pos
+      };
+      currentSection = addScaleToSection(compositeSection0, opts);
+    } else {
+      newSections.push(currentSection);
+      currentSection = nextSection;
+    }
+  }
+  if (currentSection != null) {
+    newSections.push(currentSection);
+  }
+  return newSections;
+}
+exports.buildCompositeScaleInfo = buildCompositeScaleInfo;
+exports.collapseUnconformitiesByPixelHeight = collapseUnconformitiesByPixelHeight;
+exports.computeSectionHeights = computeSectionHeights;
+exports.createCompositeScale = createCompositeScale;
+exports.createPackageScale = createPackageScale;
+exports.finalizeSectionHeights = finalizeSectionHeights;
+//# sourceMappingURL=composite-scale.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"composite-scale.cjs","sources":["../../src/prepare-units/composite-scale.ts"],"sourcesContent":["import { ColumnAxisType } from \"@macrostrat/column-components\";\nimport { ensureArray, getUnitHeightRange } from \"./utils\";\nimport { ScaleContinuousNumeric, scaleLinear } from \"d3-scale\";\nimport { UnitLong } from \"@macrostrat/api-types\";\nimport { buildHybridScale } from \"./dynamic-scales\";\nimport { ExtUnit, HybridScaleType, SectionInfo } from \"./types\";\nimport type {\n  ColumnScaleOptions,\n  CompositeColumnData,\n  CompositeScaleData,\n  PackageLayoutData,\n  PackageScaleInfo,\n  PackageScaleLayoutData,\n  SectionScaleOptions,\n} from \"./types\";\n\n// Composite scale information augmented with units in each package\n\nexport function buildCompositeScaleInfo(\n  inputScales: PackageScaleInfo[],\n  unconformityHeight: number,\n): CompositeScaleData {\n  /** Finalize the heights of sections, including the heights of unconformities\n   * between them.\n   */\n\n  let totalHeight = unconformityHeight / 2;\n  let lastSectionTopHeight = 0;\n\n  const packages2: PackageScaleLayoutData[] = [];\n  for (const group of inputScales) {\n    const { domain, scale } = group;\n    const [b_age, t_age] = domain;\n    const key = `package-${b_age}-${t_age}`;\n\n    packages2.push({\n      ...createPackageScale(group, totalHeight),\n      key,\n      offset: totalHeight,\n      // Unconformity height above this particular section\n      paddingTop: totalHeight - lastSectionTopHeight,\n    });\n\n    const pixelHeight = Math.abs(scale(b_age) - scale(t_age));\n    lastSectionTopHeight = totalHeight + pixelHeight;\n    totalHeight = lastSectionTopHeight + unconformityHeight;\n  }\n  totalHeight += unconformityHeight / 2;\n  return {\n    totalHeight,\n    sections: packages2,\n  };\n}\n\nexport function finalizeSectionHeights<T extends UnitLong>(\n  sections: SectionInfoWithScale<T>[],\n  unconformityHeight: number,\n): CompositeColumnData<T> {\n  /** Finalize the heights of sections, including the heights of unconformities\n   * between them.\n   */\n\n  const sectionScales = sections.map((d) => d.scaleInfo);\n\n  const { totalHeight, sections: packages } = buildCompositeScaleInfo(\n    sectionScales,\n    unconformityHeight,\n  );\n\n  // This could perhaps be simplified.\n  const sections1: PackageLayoutData<T>[] = [];\n  for (const i in sections) {\n    const group = sections[i];\n    const scaleInfo = packages[i];\n    sections1.push({\n      ...group,\n      key: scaleInfo.key,\n      scaleInfo,\n    });\n  }\n  return {\n    totalHeight,\n    sections: sections1,\n  };\n}\n\nexport interface SectionInfoWithScale<\n  T extends UnitLong = ExtUnit,\n> extends SectionInfo<T> {\n  scaleInfo: PackageScaleInfo;\n}\n\nexport function computeSectionHeights<T extends UnitLong>(\n  sections: SectionInfo<T>[],\n  opts: ColumnScaleOptions,\n): SectionInfoWithScale<T>[] {\n  return sections.map((group) => {\n    return addScaleToSection<T>(group, opts);\n  });\n}\n\nfunction addScaleToSection<T extends UnitLong = ExtUnit>(\n  group: SectionInfo<T>,\n  opts: ColumnScaleOptions,\n): SectionInfoWithScale<T> {\n  const { t_age, b_age, t_pos, b_pos, units } = group;\n  let _range = null;\n  // if t_age and b_age are set for a group, use them to define the range...\n  if (opts.axisType == ColumnAxisType.AGE) {\n    _range = [b_age, t_age];\n  } else {\n    _range = [b_pos, t_pos];\n  }\n\n  const scaleInfo = buildSectionScale<T>(units, {\n    ...opts,\n    domain: _range,\n  });\n\n  return {\n    ...group,\n    scaleInfo,\n  };\n}\n\nfunction buildSectionScale<T extends UnitLong>(\n  data: T[],\n  opts: SectionScaleOptions,\n): PackageScaleInfo {\n  const {\n    targetUnitHeight = 20,\n    minPixelScale = 0.2,\n    axisType,\n    minSectionHeight,\n    scale,\n    hybridScale,\n  } = opts;\n  const domain = opts.domain ?? findSectionHeightRange(data, axisType);\n\n  const dAge = Math.abs(domain[0] - domain[1]);\n\n  let _pixelScale = opts.pixelScale;\n  let pixelHeight: number;\n\n  if (hybridScale != null) {\n    /** In an equidistant surfaces scale, we want to determine the heights of surfaces\n     * and then distribute units evenly between them.\n     * This is somewhat like an ordinal scale\n     */\n    if (hybridScale.type === HybridScaleType.EquidistantSurfaces) {\n      _pixelScale ??= targetUnitHeight;\n    }\n\n    return buildHybridScale(hybridScale, data, domain, {\n      pixelOffset: 0,\n      pixelScale: _pixelScale,\n    });\n  }\n\n  if (scale == null) {\n    if (_pixelScale == null) {\n      const avgAgeRange = findAverageUnitHeight(data, axisType);\n      // Get pixel height necessary to render average unit at target height\n      _pixelScale = Math.max(targetUnitHeight / avgAgeRange, minPixelScale);\n\n      // OLD METHOD that cares about overall section height vs. individual unit height\n      // 0.2 pixel per myr is the floor scale\n      //const targetHeight = targetUnitHeight * data.length;\n      // 1 pixel per myr is the floor scale\n      //_pixelScale = Math.max(targetHeight / dAge, minPixelScale);\n    }\n\n    let height = dAge * _pixelScale;\n    // If height is less than minSectionHeight, set it to minSectionHeight\n    const _minSectionHeight = minSectionHeight ?? targetUnitHeight ?? 0;\n    pixelHeight = Math.max(height, _minSectionHeight);\n    _pixelScale = pixelHeight / dAge;\n  } else {\n    // If a scale is provided, use it to compute pixel height\n    pixelHeight = Math.abs(scale(domain[0]) - scale(domain[1]));\n  }\n\n  return createPackageScale(\n    { scale, domain, pixelHeight, pixelScale: _pixelScale },\n    0,\n  );\n}\n\nexport function createPackageScale(\n  def: PackageScaleInfo,\n  offset: number = 0,\n): PackageScaleInfo {\n  /** Build a section scale */\n  // Domain should be oriented from bottom to top, but scale is oriented from top to bottom\n  const { domain, pixelScale, pixelHeight, scale, heightScale } = def;\n\n  if (scale == null && pixelScale == null) {\n    throw new Error(\"Either scale or pixelScale must be provided\");\n  }\n\n  let _scale: ScaleContinuousNumeric<number, number>;\n  if (scale == null) {\n    _scale = scaleLinear()\n      .domain([domain[1], domain[0]])\n      .range([offset, pixelHeight + offset]);\n  } else {\n    const domain0 = scale.domain();\n    const range0 = scale.range();\n    _scale = scale\n      .copy()\n      .domain(domain0)\n      .range(range0.map((d) => d + offset));\n  }\n\n  _scale.clamp();\n\n  let _heightScale = null;\n  if (heightScale != null) {\n    // Adjust height scale as well\n    const range0 = scale.range();\n    _heightScale = heightScale.copy().range(range0.map((d) => d + offset));\n    _heightScale.clamp();\n  }\n\n  return {\n    domain,\n    pixelScale,\n    pixelHeight,\n    scale: _scale,\n    // Internal details for hybrid scales. TODO: improve this\n    heightScale: _heightScale,\n  };\n}\n\nfunction findSectionHeightRange(\n  data: UnitLong[],\n  axisType: ColumnAxisType,\n): [number, number] {\n  if (axisType == null) {\n    throw new Error(\"Axis type is not set\");\n  }\n  if (axisType === ColumnAxisType.AGE) {\n    const t_age = Math.min(...data.map((d) => d.t_age));\n    const b_age = Math.max(...data.map((d) => d.b_age));\n    return [b_age, t_age];\n  } else if (\n    axisType == ColumnAxisType.DEPTH ||\n    axisType == ColumnAxisType.ORDINAL\n  ) {\n    const t_pos = Math.min(...data.map((d) => d.t_pos));\n    const b_pos = Math.max(...data.map((d) => d.b_pos));\n    return [b_pos, t_pos];\n  } else if (axisType == ColumnAxisType.HEIGHT) {\n    const t_pos = Math.max(...data.map((d) => d.t_pos));\n    const b_pos = Math.min(...data.map((d) => d.b_pos));\n    return [b_pos, t_pos];\n  }\n}\n\nfunction findAverageUnitHeight(\n  data: UnitLong[],\n  axisType: ColumnAxisType,\n): number {\n  const unitHeights = data.map((d) => {\n    const [b_pos, t_pos] = getUnitHeightRange(d, axisType);\n    return Math.abs(b_pos - t_pos);\n  });\n  return unitHeights.reduce((a, b) => a + b, 0) / unitHeights.length;\n}\n\nexport interface CompositeColumnScale {\n  (age: number): number | null;\n  copy(): CompositeColumnScale;\n  domain(): [number, number];\n  invert(pixelHeight: number): number | null;\n  clamp(clamp: boolean): void;\n}\n\nexport function createCompositeScale(\n  sections: PackageLayoutData[],\n  interpolateUnconformities: boolean = false,\n): CompositeColumnScale {\n  /** Create a scale that works across multiple packages */\n\n  const scales: ScaleContinuousNumeric<number, number>[] = [];\n\n  let lastScale: ScaleContinuousNumeric<number, number> | null = null;\n  for (const section of sections) {\n    const _scale = section.scaleInfo.scale.copy().clamp(true);\n    scales.push(_scale);\n    if (lastScale != null && interpolateUnconformities) {\n      // Add a new scale that interpolates between lastScale and _scale\n      const lastDomain = lastScale.domain();\n      const lastRange = lastScale.range();\n      const currentDomain = _scale.domain();\n      const currentRange = _scale.range();\n\n      const interpScale = scaleLinear()\n        .domain([lastDomain[lastDomain.length - 1], currentDomain[0]])\n        .range([lastRange[lastRange.length - 1], currentRange[0]])\n        .clamp(true);\n      scales.push(interpScale);\n    }\n    lastScale = _scale;\n  }\n\n  const scale: CompositeColumnScale = (age) => {\n    for (const s of scales) {\n      const domain = s.domain();\n      if (\n        domain[0] < domain[domain.length - 1] &&\n        age >= domain[0] &&\n        age <= domain[domain.length - 1]\n      ) {\n        // Age axes\n        return s(age);\n      } else if (age <= domain[0] && age >= domain[domain.length - 1]) {\n        // Normal axes like height\n        return s(age);\n      }\n    }\n    return null;\n  };\n\n  scale.copy = () => {\n    return createCompositeScale(sections, interpolateUnconformities);\n  };\n\n  scale.domain = () => {\n    /** Return the domain of the scale */\n    const vals = sections.flatMap((d) => d.scaleInfo.domain);\n    if (vals[0] < vals[vals.length - 1]) {\n      // age axes\n      return [Math.min(...vals), Math.max(...vals)];\n    }\n    // Normal axes like height\n    return [Math.max(...vals), Math.min(...vals)];\n  };\n\n  scale.invert = (pixelHeight) => {\n    /** Invert the scale to get the age at a given pixel height */\n    // Iterate through the sections to find the correct one\n    for (const scale of scales) {\n      const range = scale.range();\n      if (\n        pixelHeight > Math.min(...range) &&\n        pixelHeight <= Math.max(...range)\n      ) {\n        console.log(\"Inverting scale at pixel height\", pixelHeight);\n        return scale.invert(pixelHeight);\n      }\n    }\n    return null;\n  };\n\n  scale.clamp = (clamp: boolean) => {\n    /** Clamp all constituent scales */\n    for (const s of scales) {\n      s.clamp(clamp);\n    }\n  };\n\n  return scale;\n}\n\n/** Collapse sections separated by unconformities that are smaller than a given pixel height. */\nexport function collapseUnconformitiesByPixelHeight<T extends UnitLong>(\n  sections: SectionInfoWithScale<T>[],\n  threshold: number,\n  opts: ColumnScaleOptions,\n): SectionInfoWithScale<T>[] {\n  const newSections = [];\n  let currentSection: SectionInfoWithScale<T> | null = null;\n  for (const nextSection of sections) {\n    if (currentSection == null) {\n      currentSection = nextSection;\n      continue;\n    }\n    let heights: [number, number];\n    let pxHeights: [number, number];\n    if (opts.axisType !== ColumnAxisType.AGE) {\n      heights = [nextSection.t_pos, currentSection.b_pos];\n    } else {\n      heights = [nextSection.t_age, currentSection.b_age];\n    }\n\n    const _diff = (vals: number[]) => {\n      return Math.abs(vals[0] - vals[1]);\n    };\n\n    pxHeights = [\n      _diff(heights.map(nextSection.scaleInfo.scale)),\n      _diff(heights.map(currentSection.scaleInfo.scale)),\n    ];\n\n    const pxHeight = Math.min(...pxHeights);\n\n    if (pxHeight < threshold) {\n      let t_pos: number;\n      let b_pos: number;\n      if (\n        opts.axisType == ColumnAxisType.AGE ||\n        opts.axisType == ColumnAxisType.DEPTH\n      ) {\n        t_pos = Math.min(currentSection.t_pos, nextSection.t_pos);\n        b_pos = Math.max(currentSection.b_pos, nextSection.b_pos);\n      } else {\n        t_pos = Math.max(currentSection.t_pos, nextSection.t_pos);\n        b_pos = Math.min(currentSection.b_pos, nextSection.b_pos);\n      }\n\n      // We need to merge the sections\n      const compositeSection0: SectionInfo<T> = {\n        units: [...currentSection.units, ...nextSection.units],\n        section_id: [\n          ...ensureArray(currentSection.section_id),\n          ...ensureArray(nextSection.section_id),\n        ],\n        t_age: Math.min(currentSection.t_age, nextSection.t_age),\n        b_age: Math.max(currentSection.b_age, nextSection.b_age),\n        t_pos,\n        b_pos,\n      };\n\n      currentSection = addScaleToSection(compositeSection0, opts);\n    } else {\n      // We need to keep the section\n      newSections.push(currentSection);\n      currentSection = nextSection;\n    }\n  }\n  if (currentSection != null) {\n    newSections.push(currentSection);\n  }\n\n  return newSections;\n}\n"],"names":["ColumnAxisType","HybridScaleType","buildHybridScale","scaleLinear","getUnitHeightRange","scale","ensureArray"],"mappings":"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"}

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

@@ -0,0 +1,19 @@
+import { UnitLong } from '@macrostrat/api-types';
+import { ExtUnit, SectionInfo, ColumnScaleOptions, CompositeColumnData, CompositeScaleData, PackageLayoutData, PackageScaleInfo } from './types';
+export declare function buildCompositeScaleInfo(inputScales: PackageScaleInfo[], unconformityHeight: number): CompositeScaleData;
+export declare function finalizeSectionHeights<T extends UnitLong>(sections: SectionInfoWithScale<T>[], unconformityHeight: number): CompositeColumnData<T>;
+export interface SectionInfoWithScale<T extends UnitLong = ExtUnit> extends SectionInfo<T> {
+    scaleInfo: PackageScaleInfo;
+}
+export declare function computeSectionHeights<T extends UnitLong>(sections: SectionInfo<T>[], opts: ColumnScaleOptions): SectionInfoWithScale<T>[];
+export declare function createPackageScale(def: PackageScaleInfo, offset?: number): PackageScaleInfo;
+export interface CompositeColumnScale {
+    (age: number): number | null;
+    copy(): CompositeColumnScale;
+    domain(): [number, number];
+    invert(pixelHeight: number): number | null;
+    clamp(clamp: boolean): void;
+}
+export declare function createCompositeScale(sections: PackageLayoutData[], interpolateUnconformities?: boolean): CompositeColumnScale;
+/** Collapse sections separated by unconformities that are smaller than a given pixel height. */
+export declare function collapseUnconformitiesByPixelHeight<T extends UnitLong>(sections: SectionInfoWithScale<T>[], threshold: number, opts: ColumnScaleOptions): SectionInfoWithScale<T>[];

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

@@ -0,0 +1,284 @@
+import { ColumnAxisType } from "@macrostrat/column-components";
+import { ensureArray, getUnitHeightRange } from "./utils.js";
+import { scaleLinear } from "d3-scale";
+import { buildHybridScale } from "./dynamic-scales.js";
+import { HybridScaleType } from "./types.js";
+function buildCompositeScaleInfo(inputScales, unconformityHeight) {
+  let totalHeight = unconformityHeight / 2;
+  let lastSectionTopHeight = 0;
+  const packages2 = [];
+  for (const group of inputScales) {
+    const { domain, scale } = group;
+    const [b_age, t_age] = domain;
+    const key = `package-${b_age}-${t_age}`;
+    packages2.push({
+      ...createPackageScale(group, totalHeight),
+      key,
+      offset: totalHeight,
+      // Unconformity height above this particular section
+      paddingTop: totalHeight - lastSectionTopHeight
+    });
+    const pixelHeight = Math.abs(scale(b_age) - scale(t_age));
+    lastSectionTopHeight = totalHeight + pixelHeight;
+    totalHeight = lastSectionTopHeight + unconformityHeight;
+  }
+  totalHeight += unconformityHeight / 2;
+  return {
+    totalHeight,
+    sections: packages2
+  };
+}
+function finalizeSectionHeights(sections, unconformityHeight) {
+  const sectionScales = sections.map((d) => d.scaleInfo);
+  const { totalHeight, sections: packages } = buildCompositeScaleInfo(
+    sectionScales,
+    unconformityHeight
+  );
+  const sections1 = [];
+  for (const i in sections) {
+    const group = sections[i];
+    const scaleInfo = packages[i];
+    sections1.push({
+      ...group,
+      key: scaleInfo.key,
+      scaleInfo
+    });
+  }
+  return {
+    totalHeight,
+    sections: sections1
+  };
+}
+function computeSectionHeights(sections, opts) {
+  return sections.map((group) => {
+    return addScaleToSection(group, opts);
+  });
+}
+function addScaleToSection(group, opts) {
+  const { t_age, b_age, t_pos, b_pos, units } = group;
+  let _range = null;
+  if (opts.axisType == ColumnAxisType.AGE) {
+    _range = [b_age, t_age];
+  } else {
+    _range = [b_pos, t_pos];
+  }
+  const scaleInfo = buildSectionScale(units, {
+    ...opts,
+    domain: _range
+  });
+  return {
+    ...group,
+    scaleInfo
+  };
+}
+function buildSectionScale(data, opts) {
+  const {
+    targetUnitHeight = 20,
+    minPixelScale = 0.2,
+    axisType,
+    minSectionHeight,
+    scale,
+    hybridScale
+  } = opts;
+  const domain = opts.domain ?? findSectionHeightRange(data, axisType);
+  const dAge = Math.abs(domain[0] - domain[1]);
+  let _pixelScale = opts.pixelScale;
+  let pixelHeight;
+  if (hybridScale != null) {
+    if (hybridScale.type === HybridScaleType.EquidistantSurfaces) {
+      _pixelScale ??= targetUnitHeight;
+    }
+    return buildHybridScale(hybridScale, data, domain, {
+      pixelOffset: 0,
+      pixelScale: _pixelScale
+    });
+  }
+  if (scale == null) {
+    if (_pixelScale == null) {
+      const avgAgeRange = findAverageUnitHeight(data, axisType);
+      _pixelScale = Math.max(targetUnitHeight / avgAgeRange, minPixelScale);
+    }
+    let height = dAge * _pixelScale;
+    const _minSectionHeight = minSectionHeight ?? targetUnitHeight ?? 0;
+    pixelHeight = Math.max(height, _minSectionHeight);
+    _pixelScale = pixelHeight / dAge;
+  } else {
+    pixelHeight = Math.abs(scale(domain[0]) - scale(domain[1]));
+  }
+  return createPackageScale(
+    { scale, domain, pixelHeight, pixelScale: _pixelScale },
+    0
+  );
+}
+function createPackageScale(def, offset = 0) {
+  const { domain, pixelScale, pixelHeight, scale, heightScale } = def;
+  if (scale == null && pixelScale == null) {
+    throw new Error("Either scale or pixelScale must be provided");
+  }
+  let _scale;
+  if (scale == null) {
+    _scale = scaleLinear().domain([domain[1], domain[0]]).range([offset, pixelHeight + offset]);
+  } else {
+    const domain0 = scale.domain();
+    const range0 = scale.range();
+    _scale = scale.copy().domain(domain0).range(range0.map((d) => d + offset));
+  }
+  _scale.clamp();
+  let _heightScale = null;
+  if (heightScale != null) {
+    const range0 = scale.range();
+    _heightScale = heightScale.copy().range(range0.map((d) => d + offset));
+    _heightScale.clamp();
+  }
+  return {
+    domain,
+    pixelScale,
+    pixelHeight,
+    scale: _scale,
+    // Internal details for hybrid scales. TODO: improve this
+    heightScale: _heightScale
+  };
+}
+function findSectionHeightRange(data, axisType) {
+  if (axisType == null) {
+    throw new Error("Axis type is not set");
+  }
+  if (axisType === ColumnAxisType.AGE) {
+    const t_age = Math.min(...data.map((d) => d.t_age));
+    const b_age = Math.max(...data.map((d) => d.b_age));
+    return [b_age, t_age];
+  } else if (axisType == ColumnAxisType.DEPTH || axisType == ColumnAxisType.ORDINAL) {
+    const t_pos = Math.min(...data.map((d) => d.t_pos));
+    const b_pos = Math.max(...data.map((d) => d.b_pos));
+    return [b_pos, t_pos];
+  } else if (axisType == ColumnAxisType.HEIGHT) {
+    const t_pos = Math.max(...data.map((d) => d.t_pos));
+    const b_pos = Math.min(...data.map((d) => d.b_pos));
+    return [b_pos, t_pos];
+  }
+}
+function findAverageUnitHeight(data, axisType) {
+  const unitHeights = data.map((d) => {
+    const [b_pos, t_pos] = getUnitHeightRange(d, axisType);
+    return Math.abs(b_pos - t_pos);
+  });
+  return unitHeights.reduce((a, b) => a + b, 0) / unitHeights.length;
+}
+function createCompositeScale(sections, interpolateUnconformities = false) {
+  const scales = [];
+  let lastScale = null;
+  for (const section of sections) {
+    const _scale = section.scaleInfo.scale.copy().clamp(true);
+    scales.push(_scale);
+    if (lastScale != null && interpolateUnconformities) {
+      const lastDomain = lastScale.domain();
+      const lastRange = lastScale.range();
+      const currentDomain = _scale.domain();
+      const currentRange = _scale.range();
+      const interpScale = scaleLinear().domain([lastDomain[lastDomain.length - 1], currentDomain[0]]).range([lastRange[lastRange.length - 1], currentRange[0]]).clamp(true);
+      scales.push(interpScale);
+    }
+    lastScale = _scale;
+  }
+  const scale = (age) => {
+    for (const s of scales) {
+      const domain = s.domain();
+      if (domain[0] < domain[domain.length - 1] && age >= domain[0] && age <= domain[domain.length - 1]) {
+        return s(age);
+      } else if (age <= domain[0] && age >= domain[domain.length - 1]) {
+        return s(age);
+      }
+    }
+    return null;
+  };
+  scale.copy = () => {
+    return createCompositeScale(sections, interpolateUnconformities);
+  };
+  scale.domain = () => {
+    const vals = sections.flatMap((d) => d.scaleInfo.domain);
+    if (vals[0] < vals[vals.length - 1]) {
+      return [Math.min(...vals), Math.max(...vals)];
+    }
+    return [Math.max(...vals), Math.min(...vals)];
+  };
+  scale.invert = (pixelHeight) => {
+    for (const scale2 of scales) {
+      const range = scale2.range();
+      if (pixelHeight > Math.min(...range) && pixelHeight <= Math.max(...range)) {
+        console.log("Inverting scale at pixel height", pixelHeight);
+        return scale2.invert(pixelHeight);
+      }
+    }
+    return null;
+  };
+  scale.clamp = (clamp) => {
+    for (const s of scales) {
+      s.clamp(clamp);
+    }
+  };
+  return scale;
+}
+function collapseUnconformitiesByPixelHeight(sections, threshold, opts) {
+  const newSections = [];
+  let currentSection = null;
+  for (const nextSection of sections) {
+    if (currentSection == null) {
+      currentSection = nextSection;
+      continue;
+    }
+    let heights;
+    let pxHeights;
+    if (opts.axisType !== ColumnAxisType.AGE) {
+      heights = [nextSection.t_pos, currentSection.b_pos];
+    } else {
+      heights = [nextSection.t_age, currentSection.b_age];
+    }
+    const _diff = (vals) => {
+      return Math.abs(vals[0] - vals[1]);
+    };
+    pxHeights = [
+      _diff(heights.map(nextSection.scaleInfo.scale)),
+      _diff(heights.map(currentSection.scaleInfo.scale))
+    ];
+    const pxHeight = Math.min(...pxHeights);
+    if (pxHeight < threshold) {
+      let t_pos;
+      let b_pos;
+      if (opts.axisType == ColumnAxisType.AGE || opts.axisType == ColumnAxisType.DEPTH) {
+        t_pos = Math.min(currentSection.t_pos, nextSection.t_pos);
+        b_pos = Math.max(currentSection.b_pos, nextSection.b_pos);
+      } else {
+        t_pos = Math.max(currentSection.t_pos, nextSection.t_pos);
+        b_pos = Math.min(currentSection.b_pos, nextSection.b_pos);
+      }
+      const compositeSection0 = {
+        units: [...currentSection.units, ...nextSection.units],
+        section_id: [
+          ...ensureArray(currentSection.section_id),
+          ...ensureArray(nextSection.section_id)
+        ],
+        t_age: Math.min(currentSection.t_age, nextSection.t_age),
+        b_age: Math.max(currentSection.b_age, nextSection.b_age),
+        t_pos,
+        b_pos
+      };
+      currentSection = addScaleToSection(compositeSection0, opts);
+    } else {
+      newSections.push(currentSection);
+      currentSection = nextSection;
+    }
+  }
+  if (currentSection != null) {
+    newSections.push(currentSection);
+  }
+  return newSections;
+}
+export {
+  buildCompositeScaleInfo,
+  collapseUnconformitiesByPixelHeight,
+  computeSectionHeights,
+  createCompositeScale,
+  createPackageScale,
+  finalizeSectionHeights
+};
+//# sourceMappingURL=composite-scale.js.map