fix: define sum options for ranges and integrals when initiating the …

…spectrum

src/component/reducer/actions/LoadActions.ts

@@ -23,6 +23,7 @@ import { ActionType } from '../types/ActionType';
 import { changeSpectrumVerticalAlignment } from './PreferencesActions';
 import { setSpectraMetaInfo } from './SpectrumsActions';
 import { setActiveTab } from './ToolsActions';
+import { StateMoleculeExtended } from '../../../data/molecules/Molecule';
 
 //TODO use viewState type instead of any { view?: ViewState }
 interface InitiateProps {
@@ -133,6 +134,7 @@ function setData(
     initSpectra(spectra, {
       usedColors: draft.usedColors,
       onLoadProcessing: autoOnLoadProcessing ? onLoadProcessing : {},
+      molecules: draft.molecules,
     }),
   );
   setCorrelation(draft, correlations);
@@ -149,15 +151,21 @@ function setData(
 
 function initSpectra(
   inputSpectra: Spectrum[],
-  options: { usedColors: UsedColors; onLoadProcessing: OnLoadProcessing },
+  options: {
+    usedColors: UsedColors;
+    onLoadProcessing: OnLoadProcessing;
+    molecules: StateMoleculeExtended[];
+  },
 ) {
   const spectra: any = [];
-  const { usedColors, onLoadProcessing } = options;
+  const { usedColors, onLoadProcessing, molecules } = options;
   for (const spectrum of inputSpectra) {
     const { info } = spectrum;
     if (info.dimension === 1) {
       const filters = onLoadProcessing?.[nucleusToString(info.nucleus)] || [];
-      spectra.push(initiateDatum1D(spectrum, { usedColors, filters }));
+      spectra.push(
+        initiateDatum1D(spectrum, { usedColors, filters, molecules }),
+      );
     } else if (info.dimension === 2) {
       spectra.push(initiateDatum2D({ ...spectrum }, { usedColors }));
     }

src/data/data1d/Spectrum1D/SumManager.ts

@@ -19,8 +19,16 @@ export interface SumParams {
 
 export type SetSumOptions = Omit<SumOptions, 'isSumConstant'>;
 
-export function initSumOptions(options: SumOptions, params: SumParams) {
-  let newOptions = { ...options };
+export function initSumOptions(
+  options: Partial<SumOptions>,
+  params: SumParams,
+) {
+  let newOptions: SumOptions = {
+    sum: undefined,
+    isSumConstant: true,
+    sumAuto: true,
+    ...options,
+  };
   const { molecules, nucleus } = params;
 
   if (options.sumAuto && Array.isArray(molecules) && molecules.length > 0) {

src/data/data1d/Spectrum1D/initiateDatum1D.ts

@@ -9,19 +9,22 @@ import { get1DColor } from './get1DColor';
 import { initiateIntegrals } from './integrals/initiateIntegrals';
 import { initiatePeaks } from './peaks/initiatePeaks';
 import { initiateRanges } from './ranges/initiateRanges';
+import { initSumOptions } from './SumManager';
+import { StateMoleculeExtended } from '../../molecules/Molecule';
 
 export interface InitiateDatum1DOptions {
   usedColors?: UsedColors;
   filters?: any[];
+  molecules?: StateMoleculeExtended[];
 }
 
 export function initiateDatum1D(
   spectrum: any,
   options: InitiateDatum1DOptions = {},
 ): Spectrum1D {
-  const { usedColors = {}, filters = [] } = options;
+  const { usedColors = {}, filters = [], molecules = [] } = options;
 
-  const { ranges, ...restSpectrum } = spectrum;
+  const { integrals, ranges, ...restSpectrum } = spectrum;
   const spectrumObj: Spectrum1D = { ...restSpectrum };
   spectrumObj.id = spectrum.id || v4();
 
@@ -52,18 +55,34 @@ export function initiateDatum1D(
 
   spectrumObj.filters = Object.assign([], spectrum.filters); //array of object {name: "FilterName", options: FilterOptions = {value | object} }
 
+  const { nucleus } = spectrumObj.info;
+
   spectrumObj.peaks = initiatePeaks(spectrum, spectrumObj);
 
   // 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`
-  spectrumObj.integrals = initiateIntegrals(spectrum, spectrumObj); // array of object (from: xIndex, to: xIndex)
-  spectrumObj.ranges = initiateRanges(spectrum, spectrumObj);
+  const integralsOptions = initSumOptions(integrals?.options || {}, {
+    nucleus,
+    molecules,
+  });
+  spectrumObj.integrals = initiateIntegrals(
+    spectrum,
+    spectrumObj,
+    integralsOptions,
+  ); // array of object (from: xIndex, to: xIndex)
+
+  const rangesOptions = initSumOptions(ranges?.options || {}, {
+    nucleus,
+    molecules,
+  });
+  spectrumObj.ranges = initiateRanges(spectrum, spectrumObj, rangesOptions);
 
   //reapply filters after load the original data
   FiltersManager.reapplyFilters(spectrumObj);
 
   preprocessing(spectrumObj, filters);
+
   return spectrumObj;
 }
 

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

@@ -3,21 +3,17 @@ import { Spectrum1D } from 'nmr-load-save';
 import { Integrals, mapIntegrals } from 'nmr-processing';
 
 export function initiateIntegrals(
-  options: Partial<{ integrals: Integrals }>,
+  inputSpectrum: Partial<Spectrum1D>,
   spectrum: Spectrum1D,
+  options: Integrals['options'],
 ) {
   return merge(
     {
       values: [],
-      options: {
-        sum: undefined,
-        isSumConstant: true,
-        sumAuto: true,
-      },
+      options,
     },
-    options.integrals,
     {
-      values: mapIntegrals(options?.integrals?.values || [], spectrum),
+      values: mapIntegrals(inputSpectrum?.integrals?.values || [], spectrum),
     },
   );
 }

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

@@ -1,12 +1,12 @@
 import merge from 'lodash/merge';
 import { Spectrum1D } from 'nmr-load-save';
-import { Peaks, mapPeaks } from 'nmr-processing';
+import { mapPeaks } from 'nmr-processing';
 
 export function initiatePeaks(
-  options: Partial<{ peaks: Peaks }>,
+  inputSpectrum: Partial<Spectrum1D>,
   spectrum: Spectrum1D,
 ) {
-  return merge({ values: [], options: {} }, options.peaks, {
-    values: mapPeaks(options?.peaks?.values || [], spectrum),
+  return merge({ values: [], options: {} }, inputSpectrum.peaks, {
+    values: mapPeaks(inputSpectrum?.peaks?.values || [], spectrum),
   });
 }

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

@@ -3,21 +3,17 @@ import { Spectrum1D } from 'nmr-load-save';
 import { Ranges, mapRanges } from 'nmr-processing';
 
 export function initiateRanges(
-  options: Partial<{ ranges: Ranges }>,
+  inputSpectrum: Partial<Spectrum1D>,
   spectrum: Spectrum1D,
+  options: Ranges['options'],
 ) {
   return merge(
     {
       values: [],
-      options: {
-        sum: undefined,
-        isSumConstant: true,
-        sumAuto: true,
-      },
+      options,
     },
-    options.ranges,
     {
-      values: mapRanges(options?.ranges?.values || [], spectrum),
+      values: mapRanges(inputSpectrum?.ranges?.values || [], spectrum),
     },
   );
 }