@complat/react-spectra-editor 1.7.0 → 1.8.0

package/dist/features/lc-ms/entities/extractEntityLCMS.js

@@ -0,0 +1,187 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.getLcMsInfo = getLcMsInfo;
+exports.isLcMsGroup = void 0;
+exports.splitAndReindexEntities = splitAndReindexEntities;
+const collectCategories = entity => {
+  const categories = [];
+  if (Array.isArray(entity.features)) {
+    entity.features.forEach(feature => {
+      if (feature?.csCategory) categories.push(...[].concat(feature.csCategory));
+    });
+  }
+  if (entity.feature?.csCategory) {
+    categories.push(...[].concat(entity.feature.csCategory));
+  }
+  if (entity.csCategory) {
+    categories.push(...[].concat(entity.csCategory));
+  }
+  return categories;
+};
+const getEntityValue = (entity, path, fallback = '') => {
+  const parts = path.split('.');
+  let current = entity;
+  for (let i = 0; i < parts.length; i += 1) {
+    if (!current) return fallback;
+    current = current[parts[i]];
+  }
+  return current ?? fallback;
+};
+const normalizeUnit = value => String(value || '').toUpperCase().replace(/\s+/g, '');
+const normalizeText = value => String(value || '').toUpperCase();
+const parseNumeric = value => {
+  if (typeof value === 'number') return Number.isFinite(value) ? value : null;
+  const text = String(value || '').trim();
+  if (!text) return null;
+  const match = text.match(/[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?/);
+  if (!match) return null;
+  const parsed = Number(match[0]);
+  return Number.isFinite(parsed) ? parsed : null;
+};
+const firstSpectrum = entity => entity?.spectra?.[0] || entity?.feature || entity?.features?.[0] || null;
+const getFirstTicX = entity => {
+  const spectrum = firstSpectrum(entity);
+  const x0 = spectrum?.data?.[0]?.x?.[0];
+  return parseNumeric(x0);
+};
+const getMzPage = entity => {
+  const spectrum = firstSpectrum(entity);
+  return parseNumeric(spectrum?.pageValue ?? spectrum?.page ?? spectrum?.pageSymbol);
+};
+function getLcMsInfo(entity = {}) {
+  if (entity.lcmsKind) {
+    return {
+      kind: entity.lcmsKind,
+      polarity: entity.lcmsPolarity || 'neutral'
+    };
+  }
+  const categories = collectCategories(entity);
+  const normalizedCategories = categories.map(String).map(category => category.toUpperCase());
+  const scanMode = normalizeText(entity.scanMode || entity.SCAN_MODE || entity.SCANMODE || getEntityValue(entity, 'info.SCAN_MODE') || getEntityValue(entity, 'info.SCANMODE') || getEntityValue(entity, 'spectra.0.scanMode') || getEntityValue(entity, 'spectra.0.SCAN_MODE') || getEntityValue(entity, 'spectra.0.SCANMODE') || getEntityValue(entity, 'feature.scanMode') || getEntityValue(entity, 'feature.SCAN_MODE') || getEntityValue(entity, 'feature.SCANMODE') || getEntityValue(entity, 'features.0.scanMode') || getEntityValue(entity, 'features.0.SCAN_MODE') || getEntityValue(entity, 'features.0.SCANMODE'));
+  const hasNeg = normalizedCategories.some(category => category.includes('NEGATIVE') || category.startsWith('NEGATIV')) || scanMode.includes('NEGATIVE') || scanMode.includes('NEGATIV');
+  const hasPos = normalizedCategories.some(category => category.includes('POSITIVE') || category.startsWith('POSITIV')) || scanMode.includes('POSITIVE') || scanMode.includes('POSITIV');
+  let polarity = 'neutral';
+  if (hasNeg) {
+    polarity = 'negative';
+  } else if (hasPos) {
+    polarity = 'positive';
+  }
+  let kind = null;
+  if (normalizedCategories.some(category => category.includes('TIC'))) kind = 'tic';
+  if (!kind && normalizedCategories.some(category => category.includes('MZ'))) kind = 'mz';
+  if (!kind && normalizedCategories.some(category => category.includes('UVVIS'))) kind = 'uvvis';
+  const dataType = String(entity.dataType || entity.DATATYPE || getEntityValue(entity, 'info.DATATYPE') || getEntityValue(entity, 'spectra.0.dataType') || getEntityValue(entity, 'spectra.0.DATATYPE') || getEntityValue(entity, 'feature.dataType') || getEntityValue(entity, 'feature.DATATYPE') || getEntityValue(entity, 'features.0.dataType') || getEntityValue(entity, 'features.0.DATATYPE')).toUpperCase();
+  const type = normalizeText(entity.type || entity.TYPE || getEntityValue(entity, 'info.TYPE') || getEntityValue(entity, 'spectra.0.type') || getEntityValue(entity, 'spectra.0.TYPE') || getEntityValue(entity, 'feature.type') || getEntityValue(entity, 'feature.TYPE') || getEntityValue(entity, 'features.0.type') || getEntityValue(entity, 'features.0.TYPE'));
+  if (!kind && dataType.includes('MASS TIC')) kind = 'tic';
+  if (!kind && dataType.includes('MASS SPECTRUM')) kind = 'mz';
+  if (!kind && (dataType.includes('UV') || dataType.includes('UV-VIS'))) kind = 'uvvis';
+  if (!kind && type.includes('CHROMATOGRAM')) kind = 'tic';
+  if (!kind && type.includes('SPECTRUM') && dataType.includes('MASS')) kind = 'mz';
+  const xUnit = normalizeUnit(entity.xUnit || getEntityValue(entity, 'spectra.0.xUnit') || getEntityValue(entity, 'feature.xUnit') || getEntityValue(entity, 'features.0.xUnit'));
+  const yUnit = normalizeUnit(entity.yUnit || getEntityValue(entity, 'spectra.0.yUnit') || getEntityValue(entity, 'feature.yUnit') || getEntityValue(entity, 'features.0.yUnit'));
+  if (!kind && xUnit.includes('M/Z')) kind = 'mz';
+  if (!kind && (xUnit.includes('TIME') || xUnit.includes('MINUTE')) && (yUnit.includes('INTENSITY') || yUnit.includes('COUNT'))) {
+    kind = 'tic';
+  }
+  if (entity.lcmsPolarity) {
+    polarity = entity.lcmsPolarity;
+  }
+  return {
+    kind: kind || 'unknown',
+    polarity
+  };
+}
+const alignMzPolarityWithTic = (ticEntities, mzEntities) => {
+  const ticByPolarity = {};
+  ticEntities.forEach(tic => {
+    const info = getLcMsInfo(tic);
+    const x = getFirstTicX(tic);
+    if (info.polarity && x != null) {
+      ticByPolarity[info.polarity] = x;
+    }
+  });
+  const ticPolarityKeys = Object.keys(ticByPolarity);
+  if (ticPolarityKeys.length < 2) return;
+  for (let i = 0; i < mzEntities.length; i += 1) {
+    const entity = mzEntities[i];
+    const mzPage = getMzPage(entity);
+    if (mzPage != null) {
+      let nearestPolarity = null;
+      let nearestDistance = Infinity;
+      ticPolarityKeys.forEach(polarity => {
+        const ticX = ticByPolarity[polarity];
+        const distance = Math.abs(mzPage - ticX);
+        if (distance < nearestDistance) {
+          nearestDistance = distance;
+          nearestPolarity = polarity;
+        }
+      });
+      if (nearestPolarity) {
+        entity.lcmsPolarity = nearestPolarity;
+      }
+    }
+  }
+};
+function splitAndReindexEntities(entities = []) {
+  const tic = [];
+  const mz = [];
+  const uvvis = [];
+  const unknown = [];
+  const normalizedEntities = entities.map(entity => ({
+    ...entity
+  }));
+  normalizedEntities.forEach(e => {
+    const info = getLcMsInfo(e);
+    e.lcmsKind = info.kind;
+    e.lcmsPolarity = info.polarity;
+    if (info.kind === 'tic') tic.push(e);else if (info.kind === 'mz') mz.push(e);else if (info.kind === 'uvvis') uvvis.push(e);else unknown.push(e);
+  });
+  alignMzPolarityWithTic(tic, mz);
+  const polarityRank = {
+    positive: 0,
+    negative: 1,
+    neutral: 2
+  };
+  const byPolarity = (a, b) => {
+    const aInfo = getLcMsInfo(a);
+    const bInfo = getLcMsInfo(b);
+    return (polarityRank[aInfo.polarity] ?? 99) - (polarityRank[bInfo.polarity] ?? 99);
+  };
+  tic.sort(byPolarity).forEach((e, i) => {
+    e.curveIdx = i;
+  });
+  mz.sort(byPolarity).forEach((e, i) => {
+    e.curveIdx = i;
+  });
+  return {
+    ticEntities: tic,
+    mzEntities: mz,
+    uvvisEntities: uvvis,
+    unknownEntities: unknown,
+    dataEntities: [...mz, ...uvvis, ...unknown],
+    allEntities: normalizedEntities
+  };
+}
+const isLcMsGroup = (entities = []) => {
+  if (!entities || !Array.isArray(entities) || entities.length === 0) {
+    return false;
+  }
+  const counts = {
+    tic: 0,
+    mz: 0,
+    uvvis: 0
+  };
+  entities.forEach(e => {
+    const {
+      kind
+    } = getLcMsInfo(e);
+    if (counts[kind] !== undefined) counts[kind] += 1;
+  });
+  return counts.uvvis > 0 && (counts.tic > 0 || counts.mz > 0);
+};
+exports.isLcMsGroup = isLcMsGroup;
+var _default = exports.default = splitAndReindexEntities;

package/dist/features/lc-ms/parsing/chemstation.js

@@ -0,0 +1,108 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseChemstationPages = exports.isChemstationLcms = void 0;
+var _lcmsMsPage = require("./lcmsMsPage");
+const parseChemstationPages = (source, jcamp) => {
+  if (typeof source !== 'string') return [];
+  const parts = source.split(/##PAGE=/);
+  if (parts.length <= 1) return [];
+  const info = jcamp?.info || {};
+  const baseSpectrum = Array.isArray(jcamp?.spectra) ? jcamp.spectra[0] : null;
+  const dataType = baseSpectrum?.dataType || jcamp?.dataType || 'LC/MS';
+  const xUnit = info.XUNITS || baseSpectrum?.xUnit || jcamp?.xUnit || '';
+  const yUnit = info.YUNITS || baseSpectrum?.yUnit || jcamp?.yUnit || '';
+  const spectra = [];
+  for (let i = 1; i < parts.length; i += 1) {
+    const block = parts[i];
+    const lines = block.split(/\r?\n/);
+    const pageLine = (lines[0] || '').trim();
+    const pageValue = (0, _lcmsMsPage.parsePageValue)(pageLine);
+    const dataStart = lines.findIndex(line => line.startsWith('##DATA TABLE') || line.startsWith('##XYDATA'));
+    if (dataStart >= 0) {
+      const x = [];
+      const y = [];
+      for (let j = dataStart + 1; j < lines.length; j += 1) {
+        const rawLine = lines[j].trim();
+        if (rawLine) {
+          if (rawLine.startsWith('##')) break;
+          const partsLine = rawLine.split(/[,\s]+/).filter(Boolean);
+          if (partsLine.length >= 2) {
+            const xVal = Number(partsLine[0]);
+            const yVal = Number(partsLine[1]);
+            if (Number.isFinite(xVal) && Number.isFinite(yVal)) {
+              x.push(xVal);
+              y.push(yVal);
+            }
+          }
+        }
+      }
+      if (x.length > 0) {
+        const pageSymbol = pageLine || pageValue;
+        spectra.push({
+          dataType,
+          xUnit,
+          yUnit,
+          pageValue,
+          page: pageLine || pageValue,
+          pageSymbol,
+          data: [{
+            x,
+            y
+          }]
+        });
+      }
+    }
+  }
+  return spectra;
+};
+exports.parseChemstationPages = parseChemstationPages;
+const isChemstationLcms = (source, jcamp) => {
+  if (typeof source !== 'string') return false;
+  const dt = String(jcamp?.dataType || jcamp?.info?.DATATYPE || '').toUpperCase();
+  if (dt.includes('LC/MS') || dt.includes('MASS TIC')) return true;
+  const spectra = Array.isArray(jcamp?.spectra) ? jcamp.spectra : [];
+  const info = jcamp?.info || {};
+  const scanMode = String(info.SCAN_MODE || info.SCANMODE || '').toUpperCase();
+  const type = String(info.TYPE || '').toUpperCase();
+  const software = String(info.SOFTWARE || '').toUpperCase();
+  const csCategory = jcamp?.info?.$CSCATEGORY;
+  const categories = Array.isArray(csCategory) ? csCategory.map(c => String(c).toUpperCase()) : [];
+  const hasPolarityCategory = categories.some(c => c.includes('POSITIVE') || c.includes('NEGATIVE') || c.includes('NEUTRAL'));
+  const hasTicOrUvvisCategory = categories.some(c => c.includes('TIC') || c.includes('UVVIS'));
+  const hasHplcUvvisSpectrumDataType = spectra.some(s => {
+    const sdt = String(s?.dataType || '').toUpperCase();
+    return sdt.includes('HPLC UV-VIS') || sdt.includes('UVVIS');
+  });
+  const hasMassTicSpectrumDataType = spectra.some(s => {
+    const sdt = String(s?.dataType || '').toUpperCase();
+    return sdt.includes('MASS TIC') || sdt.includes('TIC');
+  });
+  const hasMassSpectrumDataType = spectra.some(s => {
+    const sdt = String(s?.dataType || '').toUpperCase();
+    return sdt.includes('MASS SPECTRUM');
+  });
+  const hasMassSpectrumRootDataType = dt.includes('MASS SPECTRUM');
+  const hasScanModeHint = scanMode.includes('POSITIVE') || scanMode.includes('NEGATIVE') || scanMode.includes('POSITIV') || scanMode.includes('NEGATIV');
+  const hasTypeHint = type.includes('MS SPECTRUM') || type.includes('MS CHROMATOGRAM');
+  const hasSoftwareHint = software.includes('OPENLAB');
+  const hasMultipleSpectra = spectra.length > 1;
+  const hasPageMetadata = spectra.some(s => s?.page != null || s?.pageValue != null);
+  const hasNtuplesPageHeader = /##NTUPLES_PAGE_HEADER\s*=/.test(source);
+  if (hasNtuplesPageHeader && (hasTicOrUvvisCategory || hasHplcUvvisSpectrumDataType || hasMassTicSpectrumDataType || hasMassSpectrumDataType && hasPolarityCategory)) {
+    return true;
+  }
+  if (hasMultipleSpectra && hasPageMetadata && (hasTicOrUvvisCategory || hasHplcUvvisSpectrumDataType || hasMassTicSpectrumDataType || hasMassSpectrumDataType && hasPolarityCategory)) {
+    return true;
+  }
+  if (hasMassSpectrumRootDataType && (hasMassSpectrumDataType || hasScanModeHint || hasTypeHint || hasSoftwareHint)) {
+    return true;
+  }
+  if (hasMassTicSpectrumDataType && (hasTypeHint || hasSoftwareHint || hasScanModeHint || spectra.length > 0)) {
+    return true;
+  }
+  return false;
+};
+exports.isChemstationLcms = isChemstationLcms;

package/dist/features/lc-ms/parsing/index.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "buildLcmsMsPageJcamp", {
+  enumerable: true,
+  get: function get() {
+    return _lcmsMsPage.buildLcmsMsPageJcamp;
+  }
+});
+Object.defineProperty(exports, "inferLcMsCategory", {
+  enumerable: true,
+  get: function get() {
+    return _lcmsCategory.inferLcMsCategory;
+  }
+});
+Object.defineProperty(exports, "isChemstationLcms", {
+  enumerable: true,
+  get: function get() {
+    return _chemstation.isChemstationLcms;
+  }
+});
+Object.defineProperty(exports, "parseChemstationPages", {
+  enumerable: true,
+  get: function get() {
+    return _chemstation.parseChemstationPages;
+  }
+});
+Object.defineProperty(exports, "parseFeaturePageValue", {
+  enumerable: true,
+  get: function get() {
+    return _pageValue.parseFeaturePageValue;
+  }
+});
+Object.defineProperty(exports, "readLcmsMzPageFromJcampInfo", {
+  enumerable: true,
+  get: function get() {
+    return _lcmsJcampInfo.readLcmsMzPageFromJcampInfo;
+  }
+});
+var _lcmsCategory = require("./lcmsCategory");
+var _lcmsMsPage = require("./lcmsMsPage");
+var _lcmsJcampInfo = require("./lcmsJcampInfo");
+var _chemstation = require("./chemstation");
+var _pageValue = require("./pageValue");

package/dist/features/lc-ms/parsing/lcmsCategory.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.normalizeLcMsMode = exports.inferLcMsKind = exports.inferLcMsCategory = void 0;
+const normalizeLcMsMode = value => {
+  const mode = String(value || '').toUpperCase();
+  if (!mode) return 'NEUTRAL';
+  if (mode.includes('NEGATIVE') || mode.includes('NEGATIV')) return 'NEGATIVE';
+  if (mode.includes('POSITIVE') || mode.includes('POSITIV')) return 'POSITIVE';
+  if (mode.includes('NEUTRAL')) return 'NEUTRAL';
+  return 'NEUTRAL';
+};
+exports.normalizeLcMsMode = normalizeLcMsMode;
+const inferLcMsKind = (spectrum, jcamp) => {
+  const spectrumDataType = String(spectrum?.dataType || '').toUpperCase();
+  const jcampDataType = String(jcamp?.dataType || '').toUpperCase();
+  const type = String(jcamp?.info?.TYPE || '').toUpperCase();
+  const xUnit = String(spectrum?.xUnit || jcamp?.info?.XUNITS || jcamp?.xUnit || '').toUpperCase();
+  const yUnit = String(spectrum?.yUnit || jcamp?.info?.YUNITS || jcamp?.yUnit || '').toUpperCase();
+  if (spectrumDataType.includes('MASS TIC') || jcampDataType.includes('MASS TIC') || type.includes('CHROMATOGRAM')) {
+    return 'TIC';
+  }
+  if (spectrumDataType.includes('MASS SPECTRUM') || jcampDataType.includes('MASS SPECTRUM')) {
+    return 'MZ';
+  }
+  if (xUnit.includes('TIME') || xUnit.includes('MINUTE')) {
+    if (yUnit.includes('INTENSITY') || yUnit.includes('COUNT')) return 'TIC';
+  }
+  if (xUnit.includes('M/Z') || xUnit.includes('MZ')) return 'MZ';
+  return 'SPECTRUM';
+};
+exports.inferLcMsKind = inferLcMsKind;
+const inferLcMsCategory = (spectrum, jcamp) => {
+  const existing = spectrum?.csCategory;
+  if (existing) return existing;
+  const category = inferLcMsKind(spectrum, jcamp);
+  const mode = normalizeLcMsMode(jcamp?.info?.SCAN_MODE || jcamp?.info?.SCANMODE);
+  if (category === 'UVVIS') return 'UVVIS PEAK TABLE';
+  if (category === 'TIC' || category === 'MZ') return `${category} ${mode} SPECTRUM`;
+  return `${category} SPECTRUM`;
+};
+exports.inferLcMsCategory = inferLcMsCategory;

package/dist/features/lc-ms/parsing/lcmsJcampInfo.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.readLcmsMzPageFromJcampInfo = void 0;
+var _lcmsMsPage = require("./lcmsMsPage");
+/* eslint-disable import/prefer-default-export */
+
+const readLcmsMzPageFromJcampInfo = info => {
+  if (!info || info.$CSLCMSMZPAGE == null || info.$CSLCMSMZPAGE === '') return null;
+  const raw = info.$CSLCMSMZPAGE;
+  const scalar = Array.isArray(raw) ? raw[0] : raw;
+  if (scalar == null || scalar === '') return null;
+  const parsed = typeof scalar === 'number' && Number.isFinite(scalar) ? scalar : (0, _lcmsMsPage.parsePageValue)(String(scalar).trim());
+  return Number.isFinite(parsed) ? parsed : null;
+};
+exports.readLcmsMzPageFromJcampInfo = readLcmsMzPageFromJcampInfo;

package/dist/features/lc-ms/parsing/lcmsMsPage.js

@@ -0,0 +1,241 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.selectLcmsMsPage = exports.parsePageValue = exports.buildLcmsMsPageJcamp = void 0;
+var _extractEntityLCMS = require("../entities/extractEntityLCMS");
+const parsePageValue = raw => {
+  if (!raw) return null;
+  const match = String(raw).match(/[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?/);
+  return match ? parseFloat(match[0]) : null;
+};
+exports.parsePageValue = parsePageValue;
+const normalizeLcmsRequestPolarity = value => {
+  if (value == null || value === '') return null;
+  const text = String(value).trim().toLowerCase();
+  if (text === 'positive' || text === 'pos' || text === '+') return 'positive';
+  if (text === 'negative' || text === 'neg' || text === '-') return 'negative';
+  if (text === 'neutral' || text === 'neu' || text === '0') return 'neutral';
+  return text || null;
+};
+const stringifyLcmsPageValue = value => {
+  if (value == null) return '';
+  return String(value).trim();
+};
+const getLcmsPageCandidates = (entity = {}) => {
+  const spectra = Array.isArray(entity?.spectra) ? entity.spectra : [];
+  if (spectra.length > 0) return spectra;
+  const features = entity?.features;
+  if (Array.isArray(features)) return features;
+  if (features && typeof features === 'object') return Object.values(features);
+  if (entity?.feature) return [entity.feature];
+  return [];
+};
+const getSpectrumDataPairs = (spectrum = {}) => {
+  const data = spectrum?.data?.[0];
+  const x = Array.isArray(data?.x) ? data.x : [];
+  const y = Array.isArray(data?.y) ? data.y : [];
+  const size = Math.min(x.length, y.length);
+  return {
+    x: x.slice(0, size),
+    y: y.slice(0, size)
+  };
+};
+const describeLcmsMsSource = (entity = {}, entityIndex = -1) => {
+  const info = (0, _extractEntityLCMS.getLcMsInfo)(entity);
+  const title = entity?.title || entity?.info?.TITLE || entity?.info?.$TITLE || 'untitled';
+  const scanMode = entity?.scanMode || entity?.SCAN_MODE || entity?.info?.SCAN_MODE || entity?.info?.SCANMODE || '';
+  return {
+    index: entityIndex,
+    kind: info.kind,
+    polarity: info.polarity,
+    title,
+    scanMode,
+    spectraCount: getLcmsPageCandidates(entity).length
+  };
+};
+const selectLcmsMsPage = (entities = [], request = {}) => {
+  const retentionTimeRaw = stringifyLcmsPageValue(request?.retentionTime);
+  const retentionTime = parsePageValue(retentionTimeRaw);
+  const polarity = normalizeLcmsRequestPolarity(request?.polarity);
+  const tolerance = 1e-5;
+  const split = (0, _extractEntityLCMS.splitAndReindexEntities)(entities);
+  const mzEntities = split?.mzEntities || [];
+  if (mzEntities.length === 0) {
+    return {
+      retentionTimeRaw,
+      retentionTime,
+      polarity,
+      entity: null,
+      entityIndex: -1,
+      spectrum: null,
+      sourceFallback: false,
+      pageFallback: false
+    };
+  }
+  let candidateEntries = mzEntities.map((entity, index) => ({
+    entity,
+    index
+  }));
+  let sourceFallback = false;
+  if (candidateEntries.length === 1) {
+    const onlyPolarity = (0, _extractEntityLCMS.getLcMsInfo)(candidateEntries[0].entity).polarity;
+    sourceFallback = polarity != null && polarity !== onlyPolarity;
+  } else if (polarity != null) {
+    const matchingEntries = candidateEntries.filter(({
+      entity
+    }) => (0, _extractEntityLCMS.getLcMsInfo)(entity).polarity === polarity);
+    if (matchingEntries.length > 0) {
+      candidateEntries = matchingEntries;
+    } else {
+      sourceFallback = true;
+    }
+  }
+  let best = null;
+  candidateEntries.forEach(({
+    entity,
+    index
+  }) => {
+    getLcmsPageCandidates(entity).forEach((spectrum, spectrumIndex) => {
+      const pageValue = parsePageValue(spectrum?.pageValue ?? spectrum?.page ?? spectrum?.pageSymbol);
+      const distance = Number.isFinite(retentionTime) && Number.isFinite(pageValue) ? Math.abs(pageValue - retentionTime) : Number.POSITIVE_INFINITY;
+      const hasExactMatch = Number.isFinite(distance) && distance <= tolerance;
+      if (!best) {
+        best = {
+          entity,
+          entityIndex: index,
+          spectrum,
+          spectrumIndex,
+          pageValue,
+          distance,
+          hasExactMatch
+        };
+        return;
+      }
+      if (hasExactMatch && !best.hasExactMatch) {
+        best = {
+          entity,
+          entityIndex: index,
+          spectrum,
+          spectrumIndex,
+          pageValue,
+          distance,
+          hasExactMatch
+        };
+        return;
+      }
+      if (hasExactMatch === best.hasExactMatch && distance < best.distance) {
+        best = {
+          entity,
+          entityIndex: index,
+          spectrum,
+          spectrumIndex,
+          pageValue,
+          distance,
+          hasExactMatch
+        };
+      }
+    });
+  });
+  if (!best) {
+    const fallbackEntity = candidateEntries[0]?.entity || mzEntities[0];
+    const fallbackEntityIndex = candidateEntries[0]?.index ?? 0;
+    const fallbackSpectrum = getLcmsPageCandidates(fallbackEntity)[0] || null;
+    return {
+      retentionTimeRaw,
+      retentionTime,
+      polarity,
+      entity: fallbackEntity,
+      entityIndex: fallbackEntityIndex,
+      spectrum: fallbackSpectrum,
+      sourceFallback,
+      pageFallback: Number.isFinite(retentionTime)
+    };
+  }
+  return {
+    retentionTimeRaw,
+    retentionTime,
+    polarity,
+    entity: best.entity,
+    entityIndex: best.entityIndex,
+    spectrum: best.spectrum,
+    sourceFallback,
+    pageFallback: Number.isFinite(retentionTime) && !best.hasExactMatch
+  };
+};
+exports.selectLcmsMsPage = selectLcmsMsPage;
+const buildLcmsMsPageJcamp = (entities = [], request = {}) => {
+  const selection = selectLcmsMsPage(entities, request);
+  const {
+    retentionTimeRaw,
+    retentionTime,
+    polarity,
+    entity,
+    entityIndex,
+    spectrum,
+    sourceFallback,
+    pageFallback
+  } = selection;
+  const pageHeader = retentionTimeRaw || stringifyLcmsPageValue(spectrum?.pageValue ?? spectrum?.page ?? spectrum?.pageSymbol);
+  if (!entity || !spectrum) {
+    const emptyResult = {
+      jcamp: '',
+      selection: {
+        retentionTime: retentionTimeRaw,
+        polarity,
+        msSourceChosen: null,
+        pageChosen: null,
+        hasPageHeader: false,
+        fallbackApplied: sourceFallback || pageFallback
+      }
+    };
+    return emptyResult;
+  }
+  const {
+    x,
+    y
+  } = getSpectrumDataPairs(spectrum);
+  const points = x.map((xValue, index) => `${xValue}, ${y[index]}`);
+  const minX = x.length > 0 ? Math.min(...x) : null;
+  const maxX = x.length > 0 ? Math.max(...x) : null;
+  const minY = y.length > 0 ? Math.min(...y) : null;
+  const maxY = y.length > 0 ? Math.max(...y) : null;
+  const xUnit = spectrum?.xUnit || entity?.xUnit || entity?.info?.XUNITS || 'm/z';
+  const yUnit = spectrum?.yUnit || entity?.yUnit || entity?.info?.YUNITS || 'Intensity';
+  const scanMode = spectrum?.scanMode || entity?.scanMode || entity?.info?.SCAN_MODE || entity?.info?.SCANMODE || '';
+  const title = spectrum?.title || entity?.title || entity?.info?.TITLE || 'Spectrum';
+  const pageChosen = stringifyLcmsPageValue(spectrum?.pageValue ?? spectrum?.page ?? spectrum?.pageSymbol);
+  const lines = [`##TITLE=${title}`, '##JCAMP-DX=5.00', '##DATA TYPE=MASS SPECTRUM', '##DATA CLASS=XYPOINTS', '##ORIGIN=Chemspectra', '##OWNER=', `##XUNITS=${xUnit}`, `##YUNITS=${yUnit}`];
+  if (scanMode) lines.push(`##SCAN_MODE=${scanMode}`);
+  if (pageHeader) lines.push(`##PAGE=${pageHeader}`);
+  lines.push(`##NPOINTS=${points.length}`);
+  if (minX != null) lines.push(`##FIRSTX=${x[0]}`);
+  if (maxX != null) lines.push(`##LASTX=${x[x.length - 1]}`);
+  if (minX != null) lines.push(`##MINX=${minX}`);
+  if (maxX != null) lines.push(`##MAXX=${maxX}`);
+  if (minY != null) lines.push(`##MINY=${minY}`);
+  if (maxY != null) lines.push(`##MAXY=${maxY}`);
+  if (y.length > 0) lines.push(`##FIRSTY=${y[0]}`);
+  lines.push('##XYDATA=(XY..XY)');
+  lines.push(...points);
+  lines.push('##END=');
+  const jcamp = `${lines.join('\n')}\n`;
+  const selectionLog = {
+    retentionTime: retentionTimeRaw,
+    polarity,
+    msSourceChosen: describeLcmsMsSource(entity, entityIndex),
+    pageChosen: {
+      requested: retentionTimeRaw,
+      selected: pageChosen,
+      numericRequested: Number.isFinite(retentionTime) ? retentionTime : null
+    },
+    hasPageHeader: pageHeader ? jcamp.includes(`##PAGE=${pageHeader}`) : false,
+    fallbackApplied: sourceFallback || pageFallback
+  };
+  return {
+    jcamp,
+    selection: selectionLog
+  };
+};
+exports.buildLcmsMsPageJcamp = buildLcmsMsPageJcamp;

package/dist/features/lc-ms/parsing/pageValue.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseFeaturePageValue = void 0;
+/* eslint-disable import/prefer-default-export */
+const parseFeaturePageValue = feature => {
+  const candidates = [feature?.pageValue, feature?.page, feature?.pageSymbol];
+  for (let i = 0; i < candidates.length; i += 1) {
+    const raw = candidates[i];
+    if (raw != null) {
+      if (typeof raw === 'number') {
+        if (Number.isFinite(raw)) return raw;
+      } else {
+        const text = String(raw).split('\n')[0].trim();
+        const match = text.match(/[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?/);
+        if (match) {
+          const value = Number(match[0]);
+          if (Number.isFinite(value)) return value;
+        }
+      }
+    }
+  }
+  return null;
+};
+exports.parseFeaturePageValue = parseFeaturePageValue;