@complat/react-spectra-editor 1.7.1 → 1.8.0

package/dist/reducers/reducer_hplc_ms/hydrate.js

@@ -0,0 +1,289 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.updateLcmsData = void 0;
+var _extractEntityLCMS = require("../../helpers/extractEntityLCMS");
+var _utils = require("./utils");
+var _persistence = require("./persistence");
+var _uvvis = require("./uvvis");
+var _pageValue = require("../../features/lc-ms/parsing/pageValue");
+/* eslint-disable prefer-object-spread, import/prefer-default-export */
+
+const updateLcmsData = (state, action) => {
+  const {
+    payload,
+    meta: actionMeta
+  } = action;
+  if (!payload || payload.length === 0) return state;
+  const meta = actionMeta && typeof actionMeta === 'object' ? actionMeta : {};
+  const normalizeFeatures = curve => {
+    if (Array.isArray(curve?.features)) return curve.features;
+    if (Array.isArray(curve?.spectra)) return curve.spectra;
+    if (curve?.feature) return [curve.feature];
+    if (curve?.entity?.features) {
+      if (Array.isArray(curve.entity.features)) return curve.entity.features;
+      if (typeof curve.entity.features === 'object') {
+        return Object.values(curve.entity.features).filter(f => f?.data?.[0]);
+      }
+    }
+    if (curve?.features && typeof curve.features === 'object') {
+      return Object.values(curve.features).filter(f => f?.data?.[0]);
+    }
+    return [];
+  };
+  let ticPosData = {
+    x: [],
+    y: []
+  };
+  let ticNegData = {
+    x: [],
+    y: []
+  };
+  let ticNeutralData = {
+    x: [],
+    y: []
+  };
+  let uvvisCurve = null;
+  const mzPosFeatures = [];
+  const mzNegFeatures = [];
+  const mzNeutralFeatures = [];
+  payload.forEach(curve => {
+    const {
+      kind,
+      polarity
+    } = (0, _extractEntityLCMS.getLcMsInfo)(curve);
+    const featuresArr = normalizeFeatures(curve);
+    if (kind === 'tic') {
+      const [feature] = featuresArr;
+      const featureData = feature?.data?.[0];
+      if (!featureData || !featureData.x || featureData.x.length === 0) {
+        return;
+      }
+      if (polarity === 'negative') {
+        ticNegData = featureData;
+      } else if (polarity === 'positive') {
+        ticPosData = featureData;
+      } else {
+        ticNeutralData = featureData;
+      }
+    } else if (kind === 'uvvis') {
+      uvvisCurve = {
+        ...curve,
+        features: featuresArr
+      };
+    } else if (kind === 'mz') {
+      if (featuresArr.length === 0) return;
+      if (polarity === 'negative') {
+        mzNegFeatures.push(...featuresArr);
+      } else if (polarity === 'positive') {
+        mzPosFeatures.push(...featuresArr);
+      } else {
+        mzNeutralFeatures.push(...featuresArr);
+      }
+    }
+  });
+  if (!uvvisCurve || !uvvisCurve.features) return state;
+  const {
+    features
+  } = uvvisCurve;
+  const getPageValue = fe => {
+    let raw = fe.pageSymbol || fe.page || fe.pageValue;
+    if (typeof raw === 'string') {
+      raw = raw.split('\n')[0].trim();
+      const match = raw.match(/[=:]\s*([0-9.+-]+)/);
+      if (match) {
+        const [, value] = match;
+        raw = value;
+      } else {
+        raw = raw.replace(/[^0-9.+-]/g, '');
+      }
+    }
+    const value = parseFloat(raw);
+    return Number.isFinite(value) ? value : 0;
+  };
+  const filteredFeatures = features.filter(fe => fe.data && fe.data[0] && fe.data[0].x && fe.data[0].x.length > 0 && fe.data[0].y && fe.data[0].y.length > 0);
+  const listWaveLength = filteredFeatures.map(fe => getPageValue(fe));
+  const prevUvvis = state.uvvis || {};
+  const nextDatasetKey = meta.idDt ?? meta.datasetId ?? state.lcmsDatasetKey ?? null;
+  const sameDatasetScope = nextDatasetKey === state.lcmsDatasetKey || nextDatasetKey == null && state.lcmsDatasetKey == null;
+  const prevSpectraById = (() => {
+    const map = new Map();
+    if (!sameDatasetScope) return map;
+    const prevList = prevUvvis.spectraList || [];
+    const prevWls = prevUvvis.listWaveLength || [];
+    for (let i = 0; i < prevList.length; i += 1) {
+      const sp = prevList[i];
+      if (!sp) continue; // eslint-disable-line no-continue
+      const wl = prevWls[i];
+      const id = (0, _utils.normalizeSpectrumId)(wl ?? sp.pageValue);
+      map.set(id, sp);
+    }
+    return map;
+  })();
+  const spectraList = filteredFeatures.map(fe => {
+    const pageValue = getPageValue(fe);
+    const id = (0, _utils.normalizeSpectrumId)(pageValue);
+    const fromServer = {
+      data: fe.data[0],
+      integrations: fe.integrations || [],
+      peaks: fe.peaks || [],
+      pageValue
+    };
+    const prevSp = prevSpectraById.get(id);
+    if (!prevSp) {
+      return fromServer;
+    }
+    return {
+      ...fromServer,
+      data: fe.data[0],
+      integrations: JSON.parse(JSON.stringify(prevSp.integrations || [])),
+      peaks: (prevSp.peaks || []).map(p => ({
+        ...p
+      }))
+    };
+  });
+  const normalizedNew = listWaveLength.map(w => (0, _utils.normalizeSpectrumId)(w));
+  const metaWlHint = (0, _utils.readFiniteNumber)(meta.lcmsUvvisWavelength ?? meta.lcms_uvvis_wavelength);
+  const curveWlHint = (() => {
+    const c = uvvisCurve;
+    const v = (0, _utils.readFiniteNumber)(c?.lcms_uvvis_wavelength ?? c?.lcmsUvvisWavelength) ?? (0, _utils.readFiniteNumber)(c?.entity?.lcms_uvvis_wavelength ?? c?.entity?.lcmsUvvisWavelength);
+    return v;
+  })();
+  let wavelengthIdx = 0;
+  let resolvedFromPrev = false;
+  if (prevUvvis.selectedWaveLength != null) {
+    const idx = normalizedNew.indexOf((0, _utils.normalizeSpectrumId)(prevUvvis.selectedWaveLength));
+    if (idx >= 0) {
+      wavelengthIdx = idx;
+      resolvedFromPrev = true;
+    }
+  }
+  if (!resolvedFromPrev) {
+    const persistedWl = (0, _persistence.readPersistedLcmsUvvisWavelength)(nextDatasetKey);
+    const persistedLastWl = (0, _persistence.readPersistedLastLcmsUvvisWavelength)();
+    const hinted = metaWlHint ?? curveWlHint ?? persistedWl ?? persistedLastWl ?? null;
+    if (hinted != null) {
+      const idx = normalizedNew.indexOf((0, _utils.normalizeSpectrumId)(hinted));
+      if (idx >= 0) {
+        wavelengthIdx = idx;
+      }
+    }
+  }
+  const selectedWaveLength = listWaveLength[wavelengthIdx];
+  const currentSpectrum = spectraList[wavelengthIdx];
+  (0, _persistence.persistLcmsUvvisWavelength)(nextDatasetKey, selectedWaveLength);
+  const newUvvis = {
+    ...state.uvvis,
+    listWaveLength,
+    selectedWaveLength,
+    wavelengthIdx,
+    spectraList,
+    currentSpectrum
+  };
+  const toMsPayload = fts => {
+    const peaks = [];
+    const pageValues = [];
+    fts.forEach(feature => {
+      const data = feature?.data?.[0] || {};
+      const xValues = Array.isArray(data.x) ? data.x : [];
+      const yValues = Array.isArray(data.y) ? data.y : [];
+      const length = Math.min(xValues.length, yValues.length);
+      peaks.push(xValues.slice(0, length).map((x, i) => ({
+        x,
+        y: yValues[i] || 0
+      })));
+      pageValues.push((0, _pageValue.parseFeaturePageValue)(feature));
+    });
+    return {
+      peaks,
+      pageValues
+    };
+  };
+  const available = {
+    positive: ticPosData?.x?.length > 0,
+    negative: ticNegData?.x?.length > 0,
+    neutral: ticNeutralData?.x?.length > 0
+  };
+  const preferredOrder = ['positive', 'negative', 'neutral'];
+  const fallbackPolarity = preferredOrder.find(pol => available[pol]) || 'positive';
+  const readMetaPolarity = () => (0, _utils.normalizeHintPolarity)(meta.lcmsPolarity ?? meta.lcms_polarity ?? meta.ticPolarity);
+  const metaPol = readMetaPolarity();
+  const persistedTicHints = (0, _persistence.readPersistedLcmsTicHints)(nextDatasetKey);
+  const polarityCandidates = sameDatasetScope ? [(0, _utils.normalizeHintPolarity)(state.tic?.polarity), (0, _utils.normalizeHintPolarity)(persistedTicHints?.polarity), metaPol] : [metaPol, (0, _utils.normalizeHintPolarity)(persistedTicHints?.polarity), (0, _utils.normalizeHintPolarity)(state.tic?.polarity)];
+  const selectedPolarity = (0, _utils.pickFirstAvailablePolarity)(available, polarityCandidates) || fallbackPolarity;
+  const ticXsFor = pol => {
+    if (pol === 'negative') return ticNegData?.x;
+    if (pol === 'neutral') return ticNeutralData?.x;
+    return ticPosData?.x;
+  };
+  const nextRtXs = ticXsFor(selectedPolarity) || [];
+  const rtHintFromMzCurve = pol => {
+    const c = payload.find(curve => {
+      const inf = (0, _extractEntityLCMS.getLcMsInfo)(curve);
+      return inf.kind === 'mz' && inf.polarity === pol;
+    });
+    if (!c) return null;
+    return (0, _utils.readFiniteNumber)(c.lcms_mz_page ?? c.lcmsMzPage ?? c.entity?.lcms_mz_page ?? c.entity?.lcmsMzPage);
+  };
+  const rtFromMzFeature = pol => {
+    const findIn = list => {
+      if (!Array.isArray(list)) return null;
+      for (let i = 0; i < list.length; i += 1) {
+        const v = (0, _pageValue.parseFeaturePageValue)(list[i]);
+        if (Number.isFinite(v)) return v;
+      }
+      return null;
+    };
+    if (pol === 'negative') return findIn(mzNegFeatures);
+    if (pol === 'neutral') return findIn(mzNeutralFeatures);
+    return findIn(mzPosFeatures);
+  };
+  const metaRt = (0, _utils.readFiniteNumber)(meta.lcms_mz_page ?? meta.lcmsMzPage);
+  const curveRt = rtHintFromMzCurve(selectedPolarity);
+  const uvvisRtHint = (0, _utils.readFiniteNumber)(uvvisCurve?.lcms_mz_page ?? uvvisCurve?.lcmsMzPage ?? uvvisCurve?.entity?.lcms_mz_page ?? uvvisCurve?.entity?.lcmsMzPage);
+  const mzFeatureRt = rtFromMzFeature(selectedPolarity) ?? rtFromMzFeature('positive') ?? rtFromMzFeature('negative') ?? rtFromMzFeature('neutral');
+  const fromHints = (0, _utils.pickFirstRtOnAxis)([metaRt, uvvisRtHint, curveRt], nextRtXs) ?? nextRtXs[0] ?? null;
+  const persistedMzPage = (0, _utils.readFiniteNumber)(persistedTicHints?.mzPage);
+  const prevPageFromState = sameDatasetScope ? (0, _utils.readFiniteNumber)(state.tic?.currentPageValue) : null;
+  let nextCurrentPageValue = fromHints;
+  const snappedState = (0, _utils.snapRtToAxis)(prevPageFromState, nextRtXs);
+  const snappedPersisted = (0, _utils.snapRtToAxis)(persistedMzPage, nextRtXs);
+  if (snappedState != null) {
+    nextCurrentPageValue = snappedState;
+  } else if (snappedPersisted != null) {
+    nextCurrentPageValue = snappedPersisted;
+  }
+  if (Number.isFinite(mzFeatureRt)) {
+    nextCurrentPageValue = mzFeatureRt;
+  }
+  const sameDataset = nextDatasetKey != null && state.lcmsDatasetKey != null && nextDatasetKey === state.lcmsDatasetKey;
+  return {
+    ...state,
+    lcmsDatasetKey: nextDatasetKey,
+    uvvis: newUvvis,
+    uvvisEditHistory: sameDataset ? state.uvvisEditHistory || (0, _uvvis.emptyUvvisHistory)() : (0, _uvvis.emptyUvvisHistory)(),
+    ms: {
+      positive: toMsPayload(mzPosFeatures),
+      negative: toMsPayload(mzNegFeatures),
+      neutral: toMsPayload(mzNeutralFeatures)
+    },
+    tic: {
+      ...state.tic,
+      currentPageValue: nextCurrentPageValue,
+      polarity: selectedPolarity,
+      available,
+      positive: {
+        data: ticPosData
+      },
+      negative: {
+        data: ticNegData
+      },
+      neutral: {
+        data: ticNeutralData
+      }
+    }
+  };
+};
+exports.updateLcmsData = updateLcmsData;

package/dist/reducers/reducer_hplc_ms/index.js

@@ -0,0 +1,122 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initialState = exports.default = void 0;
+var _action_type = require("../../constants/action_type");
+var _utils = require("./utils");
+var _hydrate = require("./hydrate");
+var _uvvis = require("./uvvis");
+var _tic = require("./tic");
+/* eslint-disable default-param-last */
+
+const initialState = exports.initialState = {
+  uvvis: {
+    listWaveLength: null,
+    selectedWaveLength: null,
+    wavelengthIdx: 0,
+    spectraList: [],
+    currentSpectrum: null
+  },
+  ms: {
+    positive: {
+      peaks: [],
+      pageValues: []
+    },
+    negative: {
+      peaks: [],
+      pageValues: []
+    },
+    neutral: {
+      peaks: [],
+      pageValues: []
+    }
+  },
+  uvvisEditHistory: {
+    past: [],
+    future: []
+  },
+  tic: {
+    currentPageValue: null,
+    polarity: 'positive',
+    available: {
+      positive: false,
+      negative: false,
+      neutral: false
+    },
+    positive: {
+      data: {
+        x: [],
+        y: []
+      }
+    },
+    negative: {
+      data: {
+        x: [],
+        y: []
+      }
+    },
+    neutral: {
+      data: {
+        x: [],
+        y: []
+      }
+    }
+  },
+  threshold: {
+    isEdit: false,
+    value: 5,
+    originalValue: 5
+  },
+  lcmsIntegrationsExport: 'percent',
+  lcmsDatasetKey: null,
+  layout: 'LC/MS'
+};
+const clearState = state => ({
+  ...initialState,
+  lcmsIntegrationsExport: state?.lcmsIntegrationsExport ?? initialState.lcmsIntegrationsExport
+});
+const hplcMsReducer = (state = initialState, action) => {
+  switch (action.type) {
+    case _action_type.HPLC_MS.SET_LCMS_INTEGRATIONS_EXPORT:
+      {
+        const next = (0, _utils.normalizeLcmsIntegrationsExport)(action.payload?.lcmsIntegrationsExport);
+        return {
+          ...state,
+          lcmsIntegrationsExport: next
+        };
+      }
+    case _action_type.CURVE.SET_ALL_CURVES:
+      return (0, _hydrate.updateLcmsData)(state, action);
+    case _action_type.HPLC_MS.UPDATE_UVVIS_WAVE_LENGTH:
+      return (0, _uvvis.updateWavelength)(state, action);
+    case _action_type.HPLC_MS.SELECT_TIC_CURVE:
+      return (0, _tic.updateTic)(state, action);
+    case _action_type.HPLC_MS.UPDATE_CURRENT_PAGE_VALUE:
+      return (0, _tic.updateCurrentPageValue)(state, action);
+    case _action_type.HPLC_MS.UVVIS_UNDO:
+      return (0, _uvvis.uvvisUndo)(state);
+    case _action_type.HPLC_MS.UVVIS_REDO:
+      return (0, _uvvis.uvvisRedo)(state);
+    case _action_type.HPLC_MS.UPDATE_HPLCMS_INTEGRATIONS:
+      return (0, _uvvis.updateHplcMsIntegrations)(state, action);
+    case _action_type.HPLC_MS.UPDATE_HPLCMS_PEAKS:
+      return (0, _uvvis.updateHplcMsPeaks)(state, action);
+    case _action_type.HPLC_MS.REMOVE_HPLCMS_PEAK:
+      return (0, _uvvis.removeHplcMsPeak)(state, action);
+    case _action_type.HPLC_MS.CLEAR_INTEGRATION_ALL_HPLCMS:
+      return (0, _uvvis.clearIntegrationAllHplcMs)(state, action);
+    case _action_type.THRESHOLD.UPDATE_VALUE:
+      return (0, _tic.updateThresholdValue)(state, action);
+    case _action_type.THRESHOLD.RESET_VALUE:
+      return (0, _tic.resetThresholdValue)(state);
+    case _action_type.HPLC_MS.CLEAR_ALL_PEAKS_HPLCMS:
+      return (0, _uvvis.clearAllPeaksHplcMs)(state, action);
+    case _action_type.HPLC_MS.CLEAR_STATE:
+      return clearState(state);
+    default:
+      return state;
+  }
+};
+var _default = exports.default = hplcMsReducer;

package/dist/reducers/reducer_hplc_ms/persistence.js

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.readPersistedLcmsUvvisWavelength = exports.readPersistedLcmsTicHints = exports.readPersistedLastLcmsUvvisWavelength = exports.persistLcmsUvvisWavelength = exports.persistLcmsTicHints = void 0;
+var _utils = require("./utils");
+const LC_WL_STORAGE_PREFIX = 'rsEditor.lcmsUvvisWl:';
+const LC_WL_GLOBAL_STORAGE_KEY = 'rsEditor.lcmsUvvisWl:last';
+const persistLcmsUvvisWavelength = (datasetKey, wavelength) => {
+  if (wavelength == null) return;
+  try {
+    const normalized = String((0, _utils.normalizeSpectrumId)(wavelength));
+    sessionStorage.setItem(LC_WL_GLOBAL_STORAGE_KEY, normalized);
+    if (datasetKey != null) {
+      sessionStorage.setItem(`${LC_WL_STORAGE_PREFIX}${datasetKey}`, normalized);
+    }
+  } catch (_e) {
+    /* sessionStorage may be unavailable */
+  }
+};
+exports.persistLcmsUvvisWavelength = persistLcmsUvvisWavelength;
+const readPersistedLcmsUvvisWavelength = datasetKey => {
+  if (datasetKey == null) return null;
+  try {
+    const raw = sessionStorage.getItem(`${LC_WL_STORAGE_PREFIX}${datasetKey}`);
+    if (raw == null || raw === '') return null;
+    const n = Number(raw);
+    return Number.isFinite(n) ? n : raw;
+  } catch (e) {
+    return null;
+  }
+};
+exports.readPersistedLcmsUvvisWavelength = readPersistedLcmsUvvisWavelength;
+const readPersistedLastLcmsUvvisWavelength = () => {
+  try {
+    const raw = sessionStorage.getItem(LC_WL_GLOBAL_STORAGE_KEY);
+    if (raw == null || raw === '') return null;
+    const n = Number(raw);
+    return Number.isFinite(n) ? n : raw;
+  } catch (e) {
+    return null;
+  }
+};
+exports.readPersistedLastLcmsUvvisWavelength = readPersistedLastLcmsUvvisWavelength;
+const LC_TIC_STORAGE_PREFIX = 'rsEditor.lcmsTic:';
+const persistLcmsTicHints = (datasetKey, partial) => {
+  if (datasetKey == null) return;
+  try {
+    const key = `${LC_TIC_STORAGE_PREFIX}${datasetKey}`;
+    let cur = {};
+    const raw = sessionStorage.getItem(key);
+    if (raw) {
+      cur = JSON.parse(raw) || {};
+    }
+    sessionStorage.setItem(key, JSON.stringify({
+      ...cur,
+      ...partial
+    }));
+  } catch (_e) {
+    /* sessionStorage may be unavailable */
+  }
+};
+exports.persistLcmsTicHints = persistLcmsTicHints;
+const readPersistedLcmsTicHints = datasetKey => {
+  if (datasetKey == null) return {};
+  try {
+    const raw = sessionStorage.getItem(`${LC_TIC_STORAGE_PREFIX}${datasetKey}`);
+    return raw ? JSON.parse(raw) : {};
+  } catch (e) {
+    return {};
+  }
+};
+exports.readPersistedLcmsTicHints = readPersistedLcmsTicHints;

package/dist/reducers/reducer_hplc_ms/tic.js

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.updateTic = exports.updateThresholdValue = exports.updateCurrentPageValue = exports.resetThresholdValue = void 0;
+var _persistence = require("./persistence");
+/* eslint-disable prefer-object-spread */
+
+const updateTic = (state, action) => {
+  const {
+    polarity
+  } = action.payload;
+  (0, _persistence.persistLcmsTicHints)(state.lcmsDatasetKey, {
+    polarity
+  });
+  return {
+    ...state,
+    tic: {
+      ...state.tic,
+      polarity
+    }
+  };
+};
+exports.updateTic = updateTic;
+const updateCurrentPageValue = (state, action) => {
+  const {
+    currentPageValue
+  } = action.payload || {};
+  (0, _persistence.persistLcmsTicHints)(state.lcmsDatasetKey, {
+    mzPage: currentPageValue
+  });
+  return {
+    ...state,
+    tic: {
+      ...state.tic,
+      currentPageValue
+    }
+  };
+};
+exports.updateCurrentPageValue = updateCurrentPageValue;
+const updateThresholdValue = (state, action) => {
+  const {
+    payload
+  } = action;
+  if (payload) {
+    const {
+      value
+    } = payload;
+    return {
+      ...state,
+      threshold: {
+        isEdit: true,
+        value,
+        originalValue: state.threshold.originalValue ?? value
+      }
+    };
+  }
+  return state;
+};
+exports.updateThresholdValue = updateThresholdValue;
+const resetThresholdValue = state => ({
+  ...state,
+  threshold: {
+    isEdit: true,
+    value: state.threshold.originalValue,
+    originalValue: state.threshold.originalValue
+  }
+});
+exports.resetThresholdValue = resetThresholdValue;

package/dist/reducers/reducer_hplc_ms/utils.js

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.snapRtToAxis = exports.readFiniteNumber = exports.pickFirstRtOnAxis = exports.pickFirstAvailablePolarity = exports.normalizeSpectrumId = exports.normalizeLcmsIntegrationsExport = exports.normalizeHintPolarity = void 0;
+const normalizeSpectrumId = value => {
+  if (value == null) return null;
+  const numericValue = Number(value);
+  if (Number.isFinite(numericValue)) return numericValue;
+  return String(value);
+};
+exports.normalizeSpectrumId = normalizeSpectrumId;
+const readFiniteNumber = v => {
+  if (v == null || v === '') return null;
+  const n = Number(v);
+  return Number.isFinite(n) ? n : null;
+};
+exports.readFiniteNumber = readFiniteNumber;
+const normalizeHintPolarity = v => {
+  if (v == null || v === '') return null;
+  if (v === 0 || v === '0') return 'positive';
+  if (v === 1 || v === '1') return 'negative';
+  if (v === 2 || v === '2') return 'neutral';
+  const s = String(v).toLowerCase();
+  if (s === 'positive' || s === 'pos') return 'positive';
+  if (s === 'negative' || s === 'neg') return 'negative';
+  if (s === 'neutral' || s === 'neu') return 'neutral';
+  return null;
+};
+exports.normalizeHintPolarity = normalizeHintPolarity;
+const pickFirstAvailablePolarity = (available, candidates) => {
+  for (let i = 0; i < candidates.length; i += 1) {
+    const p = candidates[i];
+    if (p && available[p]) return p;
+  }
+  return null;
+};
+exports.pickFirstAvailablePolarity = pickFirstAvailablePolarity;
+const pickFirstRtOnAxis = (candidates, xs) => {
+  if (!Array.isArray(xs) || xs.length === 0) return null;
+  for (let i = 0; i < candidates.length; i += 1) {
+    const r = candidates[i];
+    if (Number.isFinite(r) && xs.some(x => Math.abs(x - r) < 1e-5)) {
+      return r;
+    }
+  }
+  return null;
+};
+
+/** Align an RT (e.g. user click) onto the TIC axis after a data refresh. */
+exports.pickFirstRtOnAxis = pickFirstRtOnAxis;
+const snapRtToAxis = (rt, xs) => {
+  if (!Number.isFinite(rt) || !Array.isArray(xs) || xs.length === 0) return null;
+  const exact = xs.find(x => Math.abs(x - rt) < 1e-5);
+  if (exact !== undefined) return exact;
+  let best = xs[0];
+  let bestD = Math.abs(xs[0] - rt);
+  for (let i = 1; i < xs.length; i += 1) {
+    const d = Math.abs(xs[i] - rt);
+    if (d < bestD) {
+      bestD = d;
+      best = xs[i];
+    }
+  }
+  return best;
+};
+exports.snapRtToAxis = snapRtToAxis;
+const normalizeLcmsIntegrationsExport = value => ['percent', 'area', 'both'].includes(value) ? value : 'percent';
+exports.normalizeLcmsIntegrationsExport = normalizeLcmsIntegrationsExport;