fix: nmrium crash when some keys not exists

check and map ranges, signals, peaks and integrals when import data
close #1404

src/data/data1d/Spectrum1D/getSpectrumErrorValue.ts

@@ -0,0 +1,6 @@
+import { Datum1D } from "../../types/data1d/Datum1D";
+
+export function getSpectrumErrorValue(datum: Datum1D) {
+  const { x } = datum.data;
+  return (x[x.length - 1] - x[0]) / 10000;
+}

src/data/data1d/Spectrum1D/initiateDatum1D.ts

@@ -1,11 +1,13 @@
-import merge from 'lodash/merge';
-
 import * as FiltersTypes from '../../Filters';
 import * as FiltersManager from '../../FiltersManager';
 import { Datum1D } from '../../types/data1d/Datum1D';
 import generateID from '../../utilities/generateID';
 import get1dColor from '../../utilities/getColor';
 
+import { initiateIntegrals } from './integrals/initiateIntegrals';
+import { initiatePeaks } from './peaks/initiatePeaks';
+import { initiateRanges } from './ranges/initiateRanges';
+
 export function initiateDatum1D(options: any, usedColors = {}): Datum1D {
   const datum: Partial<Datum1D> = {};
   datum.id = options.id || generateID();
@@ -55,33 +57,15 @@ export function initiateDatum1D(options: any, usedColors = {}): Datum1D {
   );
   datum.originalData = datum.data;
 
-  datum.peaks = merge({ values: [], options: {} }, options.peaks);
+  datum.filters = Object.assign([], options.filters); //array of object {name: "FilterName", options: FilterOptions = {value | object} }
+
+  datum.peaks = initiatePeaks(options, datum as Datum1D);
+
   // array of object {index: xIndex, xShift}
   // in case the peak does not exactly correspond to the point value
   // we can think about a second attributed `xShift`
-  datum.integrals = merge(
-    {
-      values: [],
-      options: {
-        sum: undefined,
-        isSumConstant: true,
-        sumAuto: true,
-      },
-    },
-    options.integrals,
-  ); // array of object (from: xIndex, to: xIndex)
-  datum.filters = Object.assign([], options.filters); //array of object {name: "FilterName", options: FilterOptions = {value | object} }
-  datum.ranges = merge(
-    {
-      values: [],
-      options: {
-        sum: undefined,
-        isSumConstant: true,
-        sumAuto: true,
-      },
-    },
-    options.ranges,
-  );
+  datum.integrals = initiateIntegrals(options); // array of object (from: xIndex, to: xIndex)
+  datum.ranges = initiateRanges(options, datum as Datum1D);
 
   //reapply filters after load the original data
   FiltersManager.reapplyFilters(datum);

src/data/data1d/Spectrum1D/integrals/initiateIntegrals.ts

@@ -0,0 +1,17 @@
+import merge from 'lodash/merge';
+
+import { Integrals } from '../../../types/data1d';
+
+export function initiateIntegrals(options: Partial<{ integrals: Integrals }>) {
+  return merge(
+    {
+      values: [],
+      options: {
+        sum: undefined,
+        isSumConstant: true,
+        sumAuto: true,
+      },
+    },
+    options.integrals,
+  );
+}

src/data/data1d/Spectrum1D/peaks/autoPeakPicking.ts

@@ -2,8 +2,8 @@ import median from 'ml-array-median';
 import { xyAutoPeaksPicking } from 'nmr-processing';
 
 import { Datum1D, Peak } from '../../../types/data1d';
-import generateID from '../../../utilities/generateID';
-import { getShiftX } from '../shift/getShiftX';
+
+import { mapPeaks } from './mapPeaks';
 
 export function autoPeakPicking(datum1D: Datum1D, options) {
   const {
@@ -18,7 +18,6 @@ export function autoPeakPicking(datum1D: Datum1D, options) {
   const noise = median(datum1D.data.re.map((y) => Math.abs(y)));
 
   let { re, x } = datum1D.data;
-  let { values: currentPeaks = [] } = datum1D.peaks || {};
 
   if (windowFromIndex !== undefined && windowToIndex !== undefined) {
     x = x.slice(windowFromIndex, windowToIndex);
@@ -39,26 +38,5 @@ export function autoPeakPicking(datum1D: Datum1D, options) {
   peaks.sort((a, b) => b.y - a.y);
   if (maxNumberOfPeaks < peaks.length) peaks = peaks.slice(0, maxNumberOfPeaks);
 
-  const shiftX = getShiftX(datum1D);
-
-  const error = (x[x.length - 1] - x[0]) / 10000;
-
-  return peaks.reduce<Peak[]>((acc, newPeak) => {
-    // check if the peak is already exists
-    for (const { x } of currentPeaks) {
-      if (Math.abs(newPeak.x - x) < error) {
-        return acc;
-      }
-    }
-
-    acc.push({
-      id: generateID(),
-      originalX: newPeak.x - shiftX,
-      x: newPeak.x,
-      y: newPeak.y,
-      width: newPeak.width,
-    });
-
-    return acc;
-  }, []);
+  return mapPeaks(peaks as Peak[], datum1D);
 }

src/data/data1d/Spectrum1D/peaks/initiatePeaks.ts

@@ -0,0 +1,18 @@
+import merge from 'lodash/merge';
+
+import { Datum1D, Peaks } from '../../../types/data1d';
+
+import { mapPeaks } from './mapPeaks';
+
+export function initiatePeaks(
+  options: Partial<{ peaks: Peaks }>,
+  datum: Datum1D,
+) {
+  return merge(
+    { values: [], options: {} },
+    options.peaks,
+    {
+      values: mapPeaks(options?.peaks?.values || [], datum),
+    },
+  );
+}

src/data/data1d/Spectrum1D/peaks/mapPeaks.ts

@@ -0,0 +1,35 @@
+import { Peak, Datum1D } from '../../../types/data1d';
+import generateID from '../../../utilities/generateID';
+import { getSpectrumErrorValue } from '../getSpectrumErrorValue';
+import { getShiftX } from '../shift/getShiftX';
+
+function checkPeak(peak: Peak, datum: Datum1D, error) {
+  // check if the Peak is already exists
+  for (const { x } of datum.peaks?.values || []) {
+    if (Math.abs(peak.x - x) < error) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export function mapPeaks(peaks: Peak[], datum: Datum1D) {
+  const shiftX = getShiftX(datum);
+
+  const error = getSpectrumErrorValue(datum);
+
+  return peaks.reduce<Peak[]>((acc, newPeak) => {
+    // check if the peak is already exists
+    if (checkPeak(newPeak, datum, error)) return acc;
+
+    acc.push({
+      id: newPeak?.id || generateID(),
+      originalX: newPeak.x - shiftX,
+      x: newPeak.x,
+      y: newPeak.y,
+      width: newPeak.width,
+    });
+
+    return acc;
+  }, []);
+}

src/data/data1d/Spectrum1D/ranges/initiateRanges.ts

@@ -0,0 +1,25 @@
+import merge from 'lodash/merge';
+
+import { Datum1D, Ranges } from '../../../types/data1d';
+
+import { mapRanges } from './mapRanges';
+
+export function initiateRanges(
+  options: Partial<{ ranges: Ranges }>,
+  datum: Datum1D,
+) {
+  return merge(
+    {
+      values: [],
+      options: {
+        sum: undefined,
+        isSumConstant: true,
+        sumAuto: true,
+      },
+    },
+    options.ranges,
+    {
+      values: mapRanges(options?.ranges?.values || [], datum),
+    },
+  );
+}

src/data/data1d/Spectrum1D/ranges/mapRanges.ts

@@ -3,22 +3,27 @@ import { xyIntegration } from 'ml-spectra-processing';
 import { DatumKind } from '../../../constants/SignalsKinds';
 import { Datum1D, Range } from '../../../types/data1d';
 import generateID from '../../../utilities/generateID';
+import { getSpectrumErrorValue } from '../getSpectrumErrorValue';
 import { getShiftX } from '../shift/getShiftX';
 
+function checkRange(range: Range, datum: Datum1D, error) {
+  // check if the range is already exists
+  for (const { from, to } of datum.ranges?.values || []) {
+    if (
+      Math.abs(range.from - from) < error &&
+      Math.abs(range.to - to) < error
+    ) {
+      return true;
+    }
+  }
+}
+
 export function mapRanges(ranges: Range[], datum: Datum1D) {
   const { x, re } = datum.data;
   const shiftX = getShiftX(datum);
-  const error = (x[x.length - 1] - x[0]) / 10000;
+  const error = getSpectrumErrorValue(datum);
   return ranges.reduce<Array<Range>>((acc, newRange) => {
-    // check if the range is already exists
-    for (const { from, to } of datum.ranges.values) {
-      if (
-        Math.abs(newRange.from - from) < error &&
-        Math.abs(newRange.to - to) < error
-      ) {
-        return acc;
-      }
-    }
+    if (checkRange(newRange, datum, error)) return acc;
 
     const absolute = xyIntegration(
       { x, y: re },