@complat/react-spectra-editor 1.7.0 → 1.8.0

package/dist/helpers/format.js

@@ -1,11 +1,9 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var _jcampconverter = _interopRequireDefault(require("jcampconverter"));
 var _converter = require("./converter");
 var _list_layout = require("../constants/list_layout");
 var _multiplicity_calc = require("./multiplicity_calc");
@@ -25,6 +23,7 @@ const spectraDigit = layout => {
     case _list_layout.LIST_LAYOUT.CDS:
     case _list_layout.LIST_LAYOUT.SEC:
     case _list_layout.LIST_LAYOUT.GC:
+    case _list_layout.LIST_LAYOUT.LC_MS:
     case _list_layout.LIST_LAYOUT.MS:
       return 0;
     case _list_layout.LIST_LAYOUT.C13:
@@ -44,6 +43,16 @@ const fixDigit = (input, precision) => {
   const output = input || 0.0;
   return output.toFixed(precision);
 };
+
+/**
+ * Integer 0–20 for toFixed; invalid input uses fallback.
+ * Default 3 preserves legacy cursor precision.
+ */
+const clampDecimalPlaces = (value, fallback = 3) => {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return fallback;
+  return Math.max(0, Math.min(20, Math.trunc(n)));
+};
 const buildData = entity => {
   if (!entity) return {
     isExist: false
@@ -63,6 +72,28 @@ const toPeakStr = peaks => {
   const str = arr.join('#');
   return str;
 };
+const extractUvvisLcmsPeaks = hplcMsSt => {
+  if (!hplcMsSt?.uvvis) {
+    return '{}';
+  }
+  const {
+    listWaveLength = [],
+    spectraList = []
+  } = hplcMsSt.uvvis;
+  const byWavelength = {};
+  spectraList.forEach((spectrum, idx) => {
+    const wl = listWaveLength[idx];
+    const wlKey = String(Math.round(wl));
+    (spectrum.peaks || []).forEach((p, n) => {
+      if (!byWavelength[wlKey]) byWavelength[wlKey] = [];
+      byWavelength[wlKey].push({
+        x: p.x,
+        y: p.y
+      });
+    });
+  });
+  return JSON.stringify(byWavelength);
+};
 const spectraOps = {
   [_list_layout.LIST_LAYOUT.PLAIN]: {
     head: '',
@@ -147,6 +178,10 @@ const spectraOps = {
   [_list_layout.LIST_LAYOUT.DLS_INTENSITY]: {
     head: 'DLS',
     tail: '.'
+  },
+  [_list_layout.LIST_LAYOUT.LC_MS]: {
+    head: 'HPLC UV/VIS',
+    tail: ''
   }
 };
 const rmRef = (peaks, shift, atIndex = 0) => {
@@ -158,6 +193,147 @@ const rmRef = (peaks, shift, atIndex = 0) => {
   const refValue = selectedShift.ref.value || selectedShift.peak.x;
   return peaks.map(p => (0, _converter.IsSame)(p.x, refValue) ? null : p).filter(r => r != null);
 };
+const isValidLcmsWavelengthLabel = wl => Number.isFinite(wl) && wl > 0;
+const LCMS_INTEGRATION_EXPORT_MODES = ['percent', 'area', 'both'];
+const isLcmsIntegrationExportMode = v => LCMS_INTEGRATION_EXPORT_MODES.includes(v);
+const formatedLCMS = (hplcMsSt, isAscend, decimal, options = {}) => {
+  if (!hplcMsSt?.uvvis) {
+    return '';
+  }
+  const {
+    lcmsIntegrationsExport: modeOpt,
+    includeIntegrationArea = false
+  } = options;
+  let lcmsIntegrationsExport = modeOpt;
+  if (!isLcmsIntegrationExportMode(lcmsIntegrationsExport)) {
+    lcmsIntegrationsExport = hplcMsSt?.lcmsIntegrationsExport;
+  }
+  if (!isLcmsIntegrationExportMode(lcmsIntegrationsExport)) {
+    lcmsIntegrationsExport = includeIntegrationArea ? 'both' : 'percent';
+  }
+  let result = '\n';
+  const sections = [];
+  const parsedDecimal = Number.isFinite(decimal) ? decimal : Number.parseInt(decimal, 10);
+  const resolvedDecimal = Number.isFinite(parsedDecimal) ? parsedDecimal : 3;
+  const {
+    listWaveLength = [],
+    spectraList = []
+  } = hplcMsSt.uvvis || {};
+  const ms = hplcMsSt.ms || {};
+  const tic = hplcMsSt.tic;
+  const threshold = hplcMsSt.threshold;
+  listWaveLength.forEach((wavelength, idx) => {
+    const spectrum = spectraList[idx];
+    if (!spectrum) {
+      return;
+    }
+    const peaks = spectrum.peaks || [];
+    const integrations = spectrum.integrations || [];
+    const stack = integrations?.[0]?.stack;
+    const hasStack = Array.isArray(stack) && stack.length > 0;
+    const hasList = !hasStack && Array.isArray(integrations) && integrations.length > 0;
+    const hasIntegrations = hasStack || hasList;
+    const hasPeaks = peaks.length > 0;
+    if (!hasPeaks && !hasIntegrations) {
+      return;
+    }
+    const lines = [];
+    if (isValidLcmsWavelengthLabel(wavelength)) {
+      lines.push(`Wavelength ${wavelength} nm:`);
+    }
+    if (hasPeaks) {
+      const sortedPeaks = [...peaks].sort((a, b) => b.y - a.y);
+      const maxIntensity = sortedPeaks[0].y || 1;
+      const peakLines = sortedPeaks.map(peak => {
+        const rt = peak.x.toFixed(resolvedDecimal);
+        const percent = (peak.y / maxIntensity * 100).toFixed(1);
+        return `${rt} min (${percent}%)`;
+      });
+      lines.push(`Peaks: ${peakLines.join(', ')}`);
+    }
+    if (hasIntegrations) {
+      const entries = hasStack ? stack : integrations;
+      const refAreaCandidate = hasStack ? integrations?.[0]?.refArea : integrations?.[0]?.refArea ?? integrations?.[0]?.area;
+      const refArea = refAreaCandidate && refAreaCandidate > 0 ? refAreaCandidate : 1;
+      const sortedIntegrations = [...entries].sort((a, b) => a.xL - b.xL);
+      const integrationLines = sortedIntegrations.map(integ => {
+        const rt = integ.xL.toFixed(resolvedDecimal);
+        const area = integ.area || integ.absoluteArea || 0;
+        const percent = (area / refArea * 100).toFixed(1);
+        const areaStr = Number.isFinite(area) ? area.toExponential(3) : String(area);
+        if (lcmsIntegrationsExport === 'area') {
+          return `${rt} min (A=${areaStr})`;
+        }
+        if (lcmsIntegrationsExport === 'both') {
+          return `${rt} min (${percent}%, A=${areaStr})`;
+        }
+        return `${rt} min (${percent}%)`;
+      });
+      lines.push(`Integrations: ${integrationLines.join(', ')}`);
+    }
+    sections.push(lines.join('\n'));
+  });
+  if (sections.length > 0) {
+    result = `\n${sections.join('\n\n')}`;
+  }
+  const polarity = tic?.polarity || 'positive';
+  let polarityKey = 'neutral';
+  if (polarity === 'negative') {
+    polarityKey = 'negative';
+  } else if (polarity === 'positive') {
+    polarityKey = 'positive';
+  }
+  let polarityLabel = '';
+  if (polarity === 'negative') {
+    polarityLabel = '−';
+  } else if (polarity === 'positive') {
+    polarityLabel = '+';
+  }
+  if (tic && ms[polarityKey]) {
+    const pageValues = Array.isArray(ms[polarityKey].pageValues) ? ms[polarityKey].pageValues : [];
+    const peaksByPage = Array.isArray(ms[polarityKey].peaks) ? ms[polarityKey].peaks : [];
+    let currentIndex = -1;
+    if (Number.isFinite(tic.currentPageValue) && pageValues.length > 0) {
+      currentIndex = pageValues.findIndex(value => Number.isFinite(value) && Math.abs(value - tic.currentPageValue) < 1e-6);
+    }
+    if (Array.isArray(tic[polarityKey]?.data?.x)) {
+      const fallbackIndex = tic[polarityKey].data.x.findIndex(x => Math.abs(x - tic.currentPageValue) < 1e-6);
+      if (currentIndex < 0) currentIndex = fallbackIndex;
+    }
+    if (currentIndex >= 0 && peaksByPage[currentIndex]) {
+      const peaks = peaksByPage[currentIndex];
+      const maxIntensity = Math.max(...peaks.map(p => p.y)) || 1;
+      const thresholdValue = threshold?.value != null ? threshold.value : 5;
+      const filtered = peaks.filter(peak => peak.y / maxIntensity * 100 >= thresholdValue);
+      const sortedPeaks = [...filtered].sort((a, b) => {
+        if (isAscend) {
+          return parseFloat(a.x) - parseFloat(b.x);
+        }
+        return parseFloat(b.x) - parseFloat(a.x);
+      });
+      const label = polarityLabel ? `${polarityLabel}ESI` : 'ESI';
+      if (result) {
+        result += '\n\n';
+      }
+      const rtPage = tic?.currentPageValue;
+      const rtDecimal = Math.max(resolvedDecimal, 3);
+      const rtPart = Number.isFinite(rtPage) ? `RT ${fixDigit(rtPage, rtDecimal)} min, ` : '';
+      result += `MS (${label}), ${rtPart}m/z (≥${thresholdValue}%):\n`;
+      const lines = sortedPeaks.map(peak => {
+        const mass = fixDigit(peak.x, resolvedDecimal);
+        const percent = Math.round(peak.y / maxIntensity * 100);
+        return `${mass} (${percent}%)`;
+      });
+      result += `  ${lines.join(', ')}`;
+    } else {
+      if (result) {
+        result += '\n\n';
+      }
+      result += 'MS: No data for current retention time.\n';
+    }
+  }
+  return result;
+};
 const formatedMS = (peaks, maxY, decimal = 2, isAscend = true) => {
   const ascendFunc = (a, b) => parseFloat(a) - parseFloat(b);
   const descendFunc = (a, b) => parseFloat(b) - parseFloat(a);
@@ -365,7 +541,8 @@ const peaksBody = ({
   integration,
   atIndex = 0,
   waveLength,
-  temperature
+  temperature,
+  hplcMsSt = null
 }) => {
   const result = rmShiftFromPeaks(peaks, shift, atIndex);
   const ascendFunc = (a, b) => parseFloat(a.x) - parseFloat(b.x);
@@ -373,6 +550,9 @@ const peaksBody = ({
   const sortFunc = isAscend ? ascendFunc : descendFunc;
   const ordered = result.sort(sortFunc);
   const maxY = Math.max(...ordered.map(o => o.y));
+  if (layout === _list_layout.LIST_LAYOUT.LC_MS) {
+    return formatedLCMS(hplcMsSt, isAscend, decimal);
+  }
   if (layout === _list_layout.LIST_LAYOUT.MS) {
     return formatedMS(ordered, maxY, decimal, isAscend);
   }
@@ -445,6 +625,7 @@ const isCyclicVoltaLayout = layoutSt => _list_layout.LIST_LAYOUT.CYCLIC_VOLTAMME
 const isCDSLayout = layoutSt => _list_layout.LIST_LAYOUT.CDS === layoutSt;
 const isSECLayout = layoutSt => _list_layout.LIST_LAYOUT.SEC === layoutSt;
 const isGCLayout = layoutSt => _list_layout.LIST_LAYOUT.GC === layoutSt;
+const isLCMsLayout = layoutSt => _list_layout.LIST_LAYOUT.LC_MS === layoutSt;
 const isEmWaveLayout = layoutSt => [_list_layout.LIST_LAYOUT.IR, _list_layout.LIST_LAYOUT.RAMAN, _list_layout.LIST_LAYOUT.UVVIS, _list_layout.LIST_LAYOUT.HPLC_UVVIS].indexOf(layoutSt) >= 0;
 const hasMultiCurves = layoutSt => [_list_layout.LIST_LAYOUT.CYCLIC_VOLTAMMETRY, _list_layout.LIST_LAYOUT.SEC, _list_layout.LIST_LAYOUT.GC, _list_layout.LIST_LAYOUT.AIF].indexOf(layoutSt) >= 0;
 const isAIFLayout = layoutSt => _list_layout.LIST_LAYOUT.AIF === layoutSt;
@@ -609,6 +790,7 @@ const inlineNotation = (layout, data, sampleName = '') => {
 };
 const Format = {
   toPeakStr,
+  extractUvvisLcmsPeaks,
   buildData,
   spectraDigit,
   spectraOps,
@@ -638,7 +820,9 @@ const Format = {
   isDLSIntensityLayout,
   isEmWaveLayout,
   isGCLayout,
+  isLCMsLayout,
   fixDigit,
+  clampDecimalPlaces,
   formatPeaksByPrediction,
   formatedMS,
   formatedEm,
@@ -651,6 +835,7 @@ const Format = {
   strNumberFixedDecimal,
   formatedXRD,
   strNumberFixedLength,
-  inlineNotation
+  inlineNotation,
+  formatedLCMS
 };
 var _default = exports.default = Format;

package/dist/helpers/init.js

@@ -55,13 +55,33 @@ const tpDiv = (d, digits, yFactor = 1) => `
     <span> y: ${d3.format('.2~e')(d.y * (yFactor || 1))}</span>
   <div>
   `;
+const msPeakTpDiv = (d, relInt, digits) => `
+  <div
+    class="peak-tp"
+    style="${tpStyle()}"
+  >
+    <span>${_format.default.fixDigit(d.x, digits)} (${relInt})</span>
+  <div>
+  `;
+const resolveDigits = (layout, xDigits) => xDigits != null && xDigits !== '' ? _format.default.clampDecimalPlaces(xDigits, _format.default.spectraDigit(layout)) : _format.default.spectraDigit(layout);
+const peakTipHtml = ({
+  d,
+  layout,
+  yFactor,
+  xDigits,
+  msMaxY
+}) => {
+  const digits = resolveDigits(layout, xDigits);
+  if (_format.default.isMsLayout(layout) && msMaxY > 0) {
+    const relPct = 100 * d.y / msMaxY;
+    const rel = parseInt(relPct, 10);
+    return msPeakTpDiv(d, rel, digits);
+  }
+  return tpDiv(d, digits, yFactor || 1);
+};
 const InitTip = () => {
   d3.select('.peak-tp').remove();
-  const tip = (0, _d3Tip.default)().attr('class', 'd3-tip').html(({
-    d,
-    layout,
-    yFactor
-  }) => tpDiv(d, _format.default.spectraDigit(layout), yFactor || 1));
+  const tip = (0, _d3Tip.default)().attr('class', 'd3-tip').html(peakTipHtml);
   return tip;
 };
 exports.InitTip = InitTip;

package/dist/helpers/integration.js

@@ -3,11 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getArea = exports.getAbsoluteArea = exports.calcArea = void 0;
+exports.splitAreaProportionally = exports.normalizeSplitLines = exports.getVisualSplitGroups = exports.getVisualSplitGroupBoundaries = exports.getSplitAreas = exports.getLinearBaseline = exports.getIntegrationPoints = exports.getArea = exports.getAbsoluteAreaWithBaseline = exports.getAbsoluteArea = exports.generateVisualSplitGroupId = exports.calcArea = exports.buildSplitIntervals = void 0;
 var _calc = require("./calc");
 /* eslint-disable no-mixed-operators */
 
 const getArea = (xL, xU, data) => {
+  if (!Array.isArray(data) || data.length === 0) return NaN;
   let [iL, iU] = [data.length - 1, 0];
   for (let i = 0; i < data.length; i += 1) {
     const pt = data[i];
@@ -23,27 +24,68 @@ const getArea = (xL, xU, data) => {
   return Math.abs(data[iU].k - data[iL].k);
 };
 exports.getArea = getArea;
-const getAbsoluteArea = (xL, xU, data) => {
-  const ps = data.filter(d => d.x > xL && d.x < xU);
-  if (!ps[0]) return 0;
-  let area = 0;
-  const point1 = ps[0];
-  const point2 = ps[ps.length - 1];
+const getIntegrationPoints = (xL, xU, data) => {
+  if (!Array.isArray(data)) return [];
+  return data.filter(d => d && Number.isFinite(d.x) && Number.isFinite(d.y) && d.x > xL && d.x < xU);
+};
+exports.getIntegrationPoints = getIntegrationPoints;
+const getLinearBaseline = points => {
+  if (!points || !points[0]) return () => 0;
+  const point1 = points[0];
+  const point2 = points[points.length - 1];
   const slope = (0, _calc.calcSlope)(point1.x, point1.y, point2.x, point2.y);
-  let lastDY = point1.y;
-  if (ps.length > 1) {
-    for (let i = 1; i < ps.length; i += 1) {
-      const pt = ps[i];
-      const lastD = ps[i - 1];
-      const y = slope * (pt.x - lastD.x) + lastDY;
-      lastDY = y;
-      const delta = Math.abs(pt.y - y);
-      area += delta;
+  return point => point1.y + slope * (point.x - point1.x);
+};
+exports.getLinearBaseline = getLinearBaseline;
+const normalizeSplitLines = splitLines => {
+  if (!Array.isArray(splitLines)) return [];
+  const finiteValues = splitLines.map(value => parseFloat(value)).filter(value => Number.isFinite(value));
+  return [...new Set(finiteValues)].sort((a, b) => a - b);
+};
+exports.normalizeSplitLines = normalizeSplitLines;
+const buildSplitIntervals = (xL, xU, splitLines = []) => {
+  if (!Number.isFinite(xL) || !Number.isFinite(xU)) return [];
+  const [lower, upper] = [xL, xU].sort((a, b) => a - b);
+  if (lower === upper) return [];
+  const sortedSplitLines = normalizeSplitLines(splitLines).filter(splitX => splitX > lower && splitX < upper);
+  return [lower, ...sortedSplitLines, upper].slice(1).map((right, index, bounds) => ({
+    xL: index === 0 ? lower : bounds[index - 1],
+    xU: right
+  }));
+};
+exports.buildSplitIntervals = buildSplitIntervals;
+const getAbsoluteAreaWithBaseline = (xL, xU, data, baselineY) => {
+  const ps = getIntegrationPoints(xL, xU, data);
+  if (ps.length < 2 || typeof baselineY !== 'function') return 0;
+  let area = 0;
+  for (let i = 1; i < ps.length; i += 1) {
+    const pt = ps[i];
+    const baselineValue = baselineY(pt);
+    if (Number.isFinite(baselineValue)) {
+      area += Math.abs(pt.y - baselineValue);
     }
   }
   return area;
 };
+exports.getAbsoluteAreaWithBaseline = getAbsoluteAreaWithBaseline;
+const getAbsoluteArea = (xL, xU, data) => {
+  const points = getIntegrationPoints(xL, xU, data);
+  const baselineY = getLinearBaseline(points);
+  return getAbsoluteAreaWithBaseline(xL, xU, data, baselineY);
+};
 exports.getAbsoluteArea = getAbsoluteArea;
+const getSplitAreas = (xL, xU, splitLines, data) => {
+  const intervals = buildSplitIntervals(xL, xU, splitLines);
+  const mainPoints = getIntegrationPoints(xL, xU, data);
+  const baselineY = getLinearBaseline(mainPoints);
+  return intervals.map(interval => ({
+    xL: interval.xL,
+    xU: interval.xU,
+    area: getArea(interval.xL, interval.xU, data),
+    absoluteArea: getAbsoluteAreaWithBaseline(interval.xL, interval.xU, data, baselineY)
+  }));
+};
+exports.getSplitAreas = getSplitAreas;
 const calcArea = (d, refArea, refFactor, ignoreRef = false) => {
   if (ignoreRef) {
     const {
@@ -53,6 +95,77 @@ const calcArea = (d, refArea, refFactor, ignoreRef = false) => {
   }
   return (d.area * refFactor / refArea).toFixed(2);
 };
+exports.calcArea = calcArea;
+const splitAreaProportionally = (totalArea, leftRaw, rightRaw) => {
+  const safeTotal = Number.isFinite(totalArea) ? totalArea : 0;
+  if (safeTotal === 0) return {
+    left: 0,
+    right: 0
+  };
+  const safeLeft = Number.isFinite(leftRaw) ? Math.max(leftRaw, 0) : 0;
+  const safeRight = Number.isFinite(rightRaw) ? Math.max(rightRaw, 0) : 0;
+  const rawSum = safeLeft + safeRight;
+  if (rawSum <= 0) {
+    const half = safeTotal / 2;
+    return {
+      left: half,
+      right: half
+    };
+  }
+  const ratio = safeTotal / rawSum;
+  return {
+    left: safeLeft * ratio,
+    right: safeRight * ratio
+  };
+};
+exports.splitAreaProportionally = splitAreaProportionally;
+let visualSplitGroupCounter = 0;
+const generateVisualSplitGroupId = () => {
+  visualSplitGroupCounter += 1;
+  const seed = typeof Date !== 'undefined' && Date.now ? Date.now().toString(36) : Math.random().toString(36).slice(2);
+  return `vsg-${seed}-${visualSplitGroupCounter}`;
+};
+exports.generateVisualSplitGroupId = generateVisualSplitGroupId;
+const getVisualSplitGroups = (stack = []) => {
+  if (!Array.isArray(stack) || stack.length === 0) return [];
+  const groups = [];
+  let current = null;
+  stack.forEach(item => {
+    const groupId = item && item.visualSplitGroupId;
+    if (groupId && current && current.groupId === groupId) {
+      current.items.push(item);
+      current.xL = Math.min(current.xL, item.xL);
+      current.xU = Math.max(current.xU, item.xU);
+    } else {
+      current = {
+        groupId: groupId || null,
+        items: [item],
+        xL: item.xL,
+        xU: item.xU,
+        isMerged: false
+      };
+      groups.push(current);
+    }
+  });
+  groups.forEach(group => {
+    // eslint-disable-next-line no-param-reassign
+    group.isMerged = !!group.groupId && group.items.length > 1;
+  });
+  return groups;
+};
+exports.getVisualSplitGroups = getVisualSplitGroups;
+const getVisualSplitGroupBoundaries = group => {
+  if (!group || !group.isMerged) return [];
+  const sortedItems = [...group.items].sort((a, b) => a.xL - b.xL);
+  const boundaries = [];
+  for (let i = 0; i < sortedItems.length - 1; i += 1) {
+    const current = sortedItems[i];
+    const next = sortedItems[i + 1];
+    const boundary = (current.xU + next.xL) / 2;
+    if (Number.isFinite(boundary)) boundaries.push(boundary);
+  }
+  return boundaries;
+};
 
 // eslint-disable-line
-exports.calcArea = calcArea;
+exports.getVisualSplitGroupBoundaries = getVisualSplitGroupBoundaries;

package/dist/helpers/integration_draft.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setPendingIntegrationDraft = exports.isDraftForCurve = exports.hasPendingIntegrationDraft = exports.forgetPendingIntegrationDraft = exports.confirmCancelPendingIntegration = exports.clearPendingIntegrationDraft = void 0;
+let pendingIntegrationDraft = null;
+const cancelMessage = 'You are currently creating an integration. Are you sure you want to cancel it?';
+const hasPendingIntegrationDraft = () => !!pendingIntegrationDraft;
+exports.hasPendingIntegrationDraft = hasPendingIntegrationDraft;
+const setPendingIntegrationDraft = draft => {
+  pendingIntegrationDraft = draft;
+};
+exports.setPendingIntegrationDraft = setPendingIntegrationDraft;
+const forgetPendingIntegrationDraft = () => {
+  pendingIntegrationDraft = null;
+};
+exports.forgetPendingIntegrationDraft = forgetPendingIntegrationDraft;
+const clearPendingIntegrationDraft = () => {
+  const draft = pendingIntegrationDraft;
+  pendingIntegrationDraft = null;
+  if (draft && typeof draft.cancel === 'function') {
+    draft.cancel();
+  }
+};
+exports.clearPendingIntegrationDraft = clearPendingIntegrationDraft;
+const confirmCancelPendingIntegration = () => {
+  if (!hasPendingIntegrationDraft()) return true;
+  const shouldCancel = typeof window === 'undefined' || typeof window.confirm !== 'function'
+  // This confirmation intentionally protects an in-progress two-click integration.
+  // eslint-disable-next-line no-alert
+  || window.confirm(cancelMessage);
+  if (shouldCancel) {
+    clearPendingIntegrationDraft();
+  }
+  return shouldCancel;
+};
+exports.confirmCancelPendingIntegration = confirmCancelPendingIntegration;
+const isDraftForCurve = (jcampIdx, dataLength) => {
+  if (!pendingIntegrationDraft) return false;
+  return pendingIntegrationDraft.jcampIdx === jcampIdx && pendingIntegrationDraft.dataLength === dataLength;
+};
+exports.isDraftForCurve = isDraftForCurve;

package/dist/helpers/integration_focus.js

@@ -0,0 +1,155 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handleVisualSplitLineClick = exports.handleIntegrationMouseMove = exports.handleIntegrationClick = exports.drawVisualSplitLinesForFocus = exports.drawIntegrationAUC = exports.buildIntegrationGroups = exports.buildIntegrationBarData = exports.bindSplitMouseHandlers = void 0;
+var _integration = require("./integration");
+var _focus = require("./focus");
+var _compass = require("./compass");
+var _cfg = _interopRequireDefault(require("./cfg"));
+var _integration_split = require("./integration_split");
+const d3 = require('d3');
+const buildIntegrationGroups = (stack = []) => (0, _integration.getVisualSplitGroups)(stack).map(group => ({
+  xL: group.xL,
+  xU: group.xU,
+  isMerged: group.isMerged,
+  groupId: group.groupId,
+  target: group.items[0]
+}));
+exports.buildIntegrationGroups = buildIntegrationGroups;
+const buildIntegrationBarData = (layout, stack = []) => {
+  const showIntegSplit = _cfg.default.showIntegSplitTools(layout);
+  const igGroups = buildIntegrationGroups(stack);
+  return {
+    showIntegSplit,
+    igGroups,
+    igBarData: showIntegSplit ? igGroups : stack
+  };
+};
+exports.buildIntegrationBarData = buildIntegrationBarData;
+const handleIntegrationMouseMove = (focus, event, data, shift, ignoreRef) => {
+  if (!focus.isUiSplitIntgSt && !focus.isUiVisualSplitIntgSt) return;
+  if (focus.isUiVisualSplitIntgSt && (0, _integration_split.isAlreadyVisuallySplit)(data)) {
+    (0, _integration_split.clearIntegrationSplitPreview)(focus);
+    return;
+  }
+  if (focus.isUiSplitIntgSt && (0, _integration_split.isMergedVisualSplitGroup)(data)) {
+    (0, _integration_split.clearIntegrationSplitPreview)(focus);
+    return;
+  }
+  const splitX = (0, _integration_split.getSplitXFromEvent)(event, focus);
+  const previewTarget = (0, _integration_split.resolveSplitTarget)(focus, data, splitX) || data;
+  (0, _integration_split.drawIntegrationSplitPreview)(focus, previewTarget, splitX, shift, ignoreRef);
+};
+exports.handleIntegrationMouseMove = handleIntegrationMouseMove;
+const handleIntegrationClick = (focus, event, data, fallbackClick) => {
+  if (!focus.isUiSplitIntgSt && !focus.isUiVisualSplitIntgSt) {
+    if (typeof fallbackClick === 'function') fallbackClick(event, data);
+    return;
+  }
+  event.stopPropagation();
+  event.preventDefault();
+  const splitX = (0, _integration_split.getSplitXFromEvent)(event, focus);
+  (0, _integration_split.clearIntegrationSplitPreview)(focus);
+  const target = (0, _integration_split.resolveSplitTarget)(focus, data, splitX);
+  if (!target) return;
+  if (focus.isUiVisualSplitIntgSt) {
+    const {
+      stack = [],
+      shift = 0
+    } = focus.integrationSplitTargets || {};
+    const existingSplitX = (0, _integration_split.getVisualSplitLineAtX)(focus, stack, splitX, shift);
+    if (Number.isFinite(existingSplitX)) {
+      if (typeof focus.removeVisualSplitLineAct !== 'function') return;
+      focus.removeVisualSplitLineAct({
+        curveIdx: focus.jcampIdx,
+        splitX: existingSplitX,
+        data: focus.data
+      });
+      return;
+    }
+    if ((0, _integration_split.isAlreadyVisuallySplit)(target)) return;
+    if (typeof focus.addVisualSplitLineAct !== 'function') return;
+    focus.addVisualSplitLineAct({
+      curveIdx: focus.jcampIdx,
+      target,
+      splitX,
+      data: focus.data
+    });
+    return;
+  }
+  if ((0, _integration_split.isMergedVisualSplitGroup)(data)) return;
+  if (typeof focus.splitIntegrationAct !== 'function') return;
+  focus.splitIntegrationAct({
+    curveIdx: focus.jcampIdx,
+    target,
+    splitX,
+    data: focus.data
+  });
+};
+exports.handleIntegrationClick = handleIntegrationClick;
+const handleVisualSplitLineClick = (focus, event, splitX) => {
+  event.stopPropagation();
+  event.preventDefault();
+  (0, _integration_split.clearIntegrationSplitPreview)(focus);
+  if (typeof focus.removeVisualSplitLineAct !== 'function') return;
+  focus.removeVisualSplitLineAct({
+    curveIdx: focus.jcampIdx,
+    splitX,
+    data: focus.data
+  });
+};
+exports.handleVisualSplitLineClick = handleVisualSplitLineClick;
+const drawVisualSplitLinesForFocus = (focus, stack, shift, ignoreRef) => {
+  (0, _integration_split.drawIntegrationVisualSplitLines)(focus, stack, shift, ignoreRef, focus.isUiVisualSplitIntgSt, (event, splitX) => handleVisualSplitLineClick(focus, event, splitX));
+};
+exports.drawVisualSplitLinesForFocus = drawVisualSplitLinesForFocus;
+const drawIntegrationAUC = (focus, stack, shift = 0) => {
+  const {
+    xt,
+    yt
+  } = (0, _compass.TfRescale)(focus);
+  const groups = buildIntegrationGroups(stack);
+  const auc = focus.tags.aucPath.selectAll('path').data(groups);
+  auc.exit().attr('class', 'exit').remove();
+  const integCurve = border => {
+    const {
+      xL,
+      xU
+    } = border;
+    const ps = (0, _integration.getIntegrationPoints)(xL - shift, xU - shift, focus.data);
+    if (!ps[0]) return null;
+    const baselineY = (0, _integration.getLinearBaseline)(ps);
+    return d3.area().x(d => xt(d.x)).y0(d => yt(baselineY(d))).y1(d => yt(d.y))(ps);
+  };
+  const showIntegSplit = _cfg.default.showIntegSplitTools(focus.layout);
+  auc.enter().append('path').attr('class', 'auc').attr('fill', 'red').attr('stroke', 'none').attr('fill-opacity', 0.2).attr('stroke-width', 2).merge(auc).attr('d', d => integCurve(d)).attr('id', d => `auc${(0, _focus.itgIdTag)(d)}`).on('mouseover', (event, d) => {
+    d3.select(`#auc${(0, _focus.itgIdTag)(d)}`).attr('stroke', 'blue');
+    d3.select(`#auc${(0, _focus.itgIdTag)(d)}`).style('fill', 'blue');
+  }).on('mouseout', (event, d) => {
+    d3.select(`#auc${(0, _focus.itgIdTag)(d)}`).attr('stroke', 'none');
+    d3.select(`#auc${(0, _focus.itgIdTag)(d)}`).style('fill', 'red');
+    d3.select(`#auc${(0, _focus.itgIdTag)(d)}`).style('fill-opacity', 0.2);
+    if (showIntegSplit) (0, _integration_split.clearIntegrationSplitPreview)(focus);
+  }).on('mousemove', showIntegSplit ? (event, d) => handleIntegrationMouseMove(focus, event, d, shift, true) : null).on('click', (event, d) => handleIntegrationClick(focus, event, d, (clickEvent, clickData) => focus.onClickTarget(clickEvent, clickData)));
+};
+exports.drawIntegrationAUC = drawIntegrationAUC;
+const bindSplitMouseHandlers = ({
+  focus,
+  shift,
+  ignoreRef,
+  showIntegSplit,
+  fallbackClick
+}) => ({
+  mouseout: (event, d) => {
+    d3.select(`#igbp${(0, _focus.itgIdTag)(d)}`).attr('stroke', '#228B22');
+    d3.select(`#igbc${(0, _focus.itgIdTag)(d)}`).attr('stroke', '#228B22');
+    d3.select(`#igtp${(0, _focus.itgIdTag)(d)}`).style('fill', '#228B22');
+    if (showIntegSplit) (0, _integration_split.clearIntegrationSplitPreview)(focus);
+  },
+  mousemove: showIntegSplit ? (event, d) => handleIntegrationMouseMove(focus, event, d, shift, ignoreRef) : null,
+  click: (event, d) => handleIntegrationClick(focus, event, d, fallbackClick)
+});
+exports.bindSplitMouseHandlers = bindSplitMouseHandlers;