nmr-processing 9.7.7 → 9.7.9-pre.1690349439

package/src/assignment/utils/{buildAssignments.ts → oneDimensionalAssignment/buildAssignments.ts}

@@ -1,6 +1,6 @@
 import TreeSet from 'ml-tree-set';
 
-import { Targets, NMRSignal1DWithAtomsAndDiaIDs } from '../get1HAssignments';
+import { Targets, NMRSignal1DWithAtomsAndDiaIDs } from '../../get1HAssignments';
 
 import { createMapPossibleAssignments } from './createMapPossibleAssignments';
 import { exploreTreeRec } from './exploreTreeRec';
@@ -33,9 +33,7 @@ export interface Signals1DAssignment extends NMRSignal1DWithAtomsAndDiaIDs {
   error?: number;
 }
 
-export interface Predictions1Dassignments {
-  [key: string]: Signals1DAssignment;
-}
+export type Predictions1Dassignments = Record<string, Signals1DAssignment>;
 
 export interface StoreAssignments {
   solutions: TreeSet;
@@ -65,10 +63,10 @@ export async function buildAssignments(props: BuildAssignmentsProps) {
     nSolutions: 0,
   };
 
-  let nSources = joinedSignals.length;
+  const nSources = joinedSignals.length;
   const predictions: Predictions1Dassignments = {};
 
-  for (let prediction of joinedSignals) {
+  for (const prediction of joinedSignals) {
     const diaID = prediction.diaIDs[0];
     const index = prediction.atoms[0];
     predictions[diaID] = {
@@ -91,7 +89,7 @@ export async function buildAssignments(props: BuildAssignmentsProps) {
 
   const diaIDPeerPossibleAssignment = Object.keys(possibleAssignmentMap);
 
-  let partial = fillPartial(nSources);
+  const partial = fillPartial(nSources);
 
   store = {
     solutions: new TreeSet(comparator),
@@ -129,7 +127,7 @@ export async function buildAssignments(props: BuildAssignmentsProps) {
     const { assignment, score } = solution;
     const currentAssignment = JSON.parse(JSON.stringify(targets));
     for (let i = 0; i < assignment.length; i++) {
-      let range = currentAssignment[assignment[i]];
+      const range = currentAssignment[assignment[i]];
       if (!range.diaIDs) range.diaIDs = [];
       if (assignment[i]) range.diaIDs.push(diaIDPeerPossibleAssignment[i]);
     }

package/src/assignment/utils/{createMapPossibleAssignments.ts → oneDimensionalAssignment/createMapPossibleAssignments.ts}

@@ -1,5 +1,5 @@
-import { MakeMandatory } from '../../utilities/MakeMandatory';
-import type { Targets } from '../get1HAssignments';
+import { MakeMandatory } from '../../../utilities/MakeMandatory';
+import type { Targets } from '../../get1HAssignments';
 
 import type {
   RestrictionByCS1D,
@@ -18,9 +18,7 @@ interface CreateMapPossibleAssignments {
   useIntegrationRestriction: boolean;
 }
 
-export interface PossibleAssignmentMap {
-  [key: string]: string[];
-}
+export type PossibleAssignmentMap = Record<string, string[]>;
 export function createMapPossibleAssignments(
   props: CreateMapPossibleAssignments,
 ) {
@@ -29,16 +27,16 @@ export function createMapPossibleAssignments(
 
   const { tolerance: toleranceCS, chemicalShiftRestriction } = restrictionByCS;
 
-  let errorAbs = Math.abs(toleranceCS);
+  const errorAbs = Math.abs(toleranceCS);
   const expandMap: PossibleAssignmentMap = {};
   for (const diaID in predictions) {
-    let prediction = predictions[diaID];
+    const prediction = predictions[diaID];
     if (prediction.error) prediction.error = Math.abs(prediction.error);
     expandMap[diaID] = [];
 
     if (targets) {
       for (const targetID in targets) {
-        let target = targets[targetID];
+        const target = targets[targetID];
         const { nbAtoms } = prediction;
         const { integration } = target;
 
@@ -65,7 +63,9 @@ export function createMapPossibleAssignments(
                 ? target.signals[0].delta
                 : (target.to + target.from) / 2;
 
-            let distAfterLimit = Math.abs(prediction.delta - delta - errorAbs);
+            const distAfterLimit = Math.abs(
+              prediction.delta - delta - errorAbs,
+            );
             if (distAfterLimit < 4 * errorAbs) {
               expandMap[diaID].push(targetID);
             }

package/src/assignment/utils/{exploreTreeRec.ts → oneDimensionalAssignment/exploreTreeRec.ts}

@@ -1,4 +1,4 @@
-import type { Targets } from '../get1HAssignments';
+import type { Targets } from '../../get1HAssignments';
 
 import type {
   RestrictionByCS1D,
@@ -50,9 +50,9 @@ export function exploreTreeRec(
 
   const diaID = diaIDPeerPossibleAssignment[currentIndex];
   const possibleAssignments = possibleAssignmentMap[diaID];
-  for (let targetID of possibleAssignments) {
+  for (const targetID of possibleAssignments) {
     partial[currentIndex] = targetID;
-    let score = partialScore(partial, {
+    const score = partialScore(partial, {
       useIntegrationRestriction,
       diaIDPeerPossibleAssignment,
       nbAllowedUnAssigned,
@@ -107,12 +107,11 @@ interface AddSolutionProps {
 }
 
 function addSolution(store: StoreAssignments, props: AddSolutionProps) {
-  let { score, maxSolutions, partial, predictions } = props;
-  score /= doubleAssignmentPenalty(partial, predictions);
+  const { score, maxSolutions, partial, predictions } = props;
   store.nSolutions++;
-  let solution: SolutionAssignment = {
+  const solution: SolutionAssignment = {
     assignment: JSON.parse(JSON.stringify(partial)),
-    score,
+    score: score / doubleAssignmentPenalty(partial, predictions),
   };
 
   if (store.nSolutions >= maxSolutions) {
@@ -131,7 +130,7 @@ function doubleAssignmentPenalty(
   predictions: Predictions1Dassignments,
 ) {
   const nbSources = Object.keys(predictions).length;
-  let assignments = new Set(partial);
-  let nbDoubleAssignment = nbSources - assignments.size;
+  const assignments = new Set(partial);
+  const nbDoubleAssignment = nbSources - assignments.size;
   return nbDoubleAssignment > 0 ? 2 * nbDoubleAssignment : 1;
 }

package/src/assignment/utils/{partialScore.ts → oneDimensionalAssignment/partialScore.ts}

@@ -1,4 +1,4 @@
-import { Targets } from '../get1HAssignments';
+import { Targets } from '../../get1HAssignments';
 
 import type {
   Predictions1Dassignments,
@@ -32,11 +32,9 @@ export function partialScore(
   } = options;
   const { useChemicalShiftScore } = restrictionByCS;
   let countStars = 0;
-  let totalPartial = partial.length;
-  let partialInverse: {
-    [key: string]: string[];
-  } = {};
-  let activeDomainOnPrediction: number[] = [];
+  const totalPartial = partial.length;
+  const partialInverse: Record<string, string[]> = {};
+  const activeDomainOnPrediction: number[] = [];
 
   for (let i = 0; i < partial.length; i++) {
     const targetID = partial[i];
@@ -58,8 +56,8 @@ export function partialScore(
   }
 
   if (useIntegrationRestriction) {
-    for (let targetID of activeDomainOnTarget) {
-      let targetToSource = partialInverse[targetID];
+    for (const targetID of activeDomainOnTarget) {
+      const targetToSource = partialInverse[targetID];
       let total = 0;
       for (const diaID of targetToSource) {
         const prediction = predictions[diaID];
@@ -74,7 +72,7 @@ export function partialScore(
   }
 
   //chemical shift score
-  let chemicalShiftScore = useChemicalShiftScore
+  const chemicalShiftScore = useChemicalShiftScore
     ? chemicalShiftScoring(partial, options)
     : 1;
 
@@ -96,9 +94,9 @@ function chemicalShiftScoring(
     const targetID = partial[index];
     if (targetID && targetID !== '*') {
       count++;
-      let diaID = diaIDPeerPossibleAssignment[index];
-      let source = predictions[diaID];
-      let target = targets[targetID];
+      const diaID = diaIDPeerPossibleAssignment[index];
+      const source = predictions[diaID];
+      const target = targets[targetID];
       let error = tolerance;
       if (source.error) {
         error = Math.max(source.error, tolerance);

package/src/constants/SignalsKinds.ts

@@ -1,4 +1,4 @@
-export const SignalKinds: { label: string; value: string }[] = [
+export const SignalKinds: Array<{ label: string; value: string }> = [
   {
     label: 'Signal',
     value: 'signal',

package/src/constants/couplingValues.ts

@@ -1,6 +1,6 @@
 import { MultiplicityPatterns } from './MultiplicityPatterns';
 
-const result: { [key: string]: number } = {};
+const result: Record<string, number> = {};
 for (const { value, multiplicity, names } of MultiplicityPatterns) {
   if (multiplicity) result[value] = multiplicity - 1;
   for (const name of names) {

package/src/constants/impurities.ts

@@ -1,19 +1,5 @@
-export interface SolventImpurities {
-  [key: string]: Impurity;
-}
-
-export interface Impurity {
-  [key: string]: ImpuritySignal[];
-}
-
-export interface ImpuritySignal {
-  proton: string;
-  coupling: number;
-  multiplicity: string;
-  shift: number;
-}
 /* eslint-disable camelcase */
-export const impurities: SolventImpurities = {
+const impuritiesContent = {
   cdcl3: {
     tms: [
       {
@@ -3144,3 +3130,16 @@ export const impurities: SolventImpurities = {
     ],
   },
 };
+export type SolventImpurities = Record<Solvent, Impurity>;
+
+export type Impurity = Record<string, ImpuritySignal[]>;
+
+export type Solvent = keyof typeof impuritiesContent;
+
+export interface ImpuritySignal {
+  proton: string;
+  coupling: number;
+  multiplicity: string;
+  shift: number;
+}
+export const impurities: SolventImpurities = impuritiesContent;

package/src/databases/getDatabase.ts

@@ -36,7 +36,7 @@ export async function getDatabase(
 
   const results = [];
 
-  for (let line of parsed.data) {
+  for (const line of parsed.data) {
     const result: DatabaseNMREntry = {
       smiles: '',
       solvent: '',

package/src/datum/Filters.ts

@@ -11,6 +11,8 @@ import * as signalProcessing from './data1d/filter1d/signalProcessing';
 import * as zeroFilling from './data1d/filter1d/zeroFilling';
 import * as shift2DX from './data2d/filter2d/shiftX';
 import * as shift2DY from './data2d/filter2d/shiftY';
+import * as fftDimension1 from './data2d/filter2d/fftDimension1';
+import * as fftDimension2 from './data2d/filter2d/fftDimension2';
 
 export type { ApodizationOptions } from './data1d/filter1d/apodization/apodization';
 export type {
@@ -46,6 +48,8 @@ export const Filters: Record<
   digitalFilter,
   equallySpaced,
   fft,
+  fftDimension1,
+  fftDimension2,
   phaseCorrection,
   shiftX,
   zeroFilling,

package/src/datum/FiltersManager.ts

@@ -43,7 +43,7 @@ function updateData(datum: Entry1D | Entry2D) {
 
 interface ApplyFilterOptions {
   forceReapply?: boolean;
-  filterIndex?: number | -1;
+  filterIndex?: number;
 }
 
 interface FilterOption {
@@ -62,7 +62,7 @@ export function applyFilter(
 ) {
   const { forceReapply = false, filterIndex } = options;
   let isReduced = false;
-  for (let filter of filters) {
+  for (const filter of filters) {
     const filterOption = {
       name: filter.name,
       label: Filters[filter.name].name,
@@ -99,7 +99,7 @@ export function applyFilter(
       reapplyFilters(datum);
     }
   } else {
-    for (let filter of filters) {
+    for (const filter of filters) {
       Filters[filter.name].apply(datum, filter.value);
     }
   }

package/src/datum/MatrixOptions.ts

@@ -7,7 +7,7 @@ export interface MatrixOptions {
    * @default []
    *
    */
-  filters: (MatrixFilter & { options: object })[];
+  filters: Array<MatrixFilter & { options: object }>;
   /**
    * Exclusion zones
    * @default []

package/src/datum/data1d/Entry1D.ts

@@ -15,5 +15,5 @@ export interface Entry1D {
   ranges: Ranges;
   info: Info1D;
   originalInfo?: Info1D;
-  filters: Array<Filter>;
+  filters: Filter[];
 }

package/src/datum/data1d/filter1d/baselineCorrection.ts

@@ -40,7 +40,7 @@ export function apply(datum1D: Entry1D, options: BaselineCorrectionOptions) {
     throw new Error('baselineCorrection not applicable on this data');
   }
   const { algorithm } = options;
-  let { x, re } = datum1D.data;
+  const { x, re } = datum1D.data;
 
   let corrected;
   switch (algorithm) {
@@ -50,14 +50,14 @@ export function apply(datum1D: Entry1D, options: BaselineCorrectionOptions) {
     case 'polynomial':
       {
         const { degree, zones } = options;
-        let reduced = xyEquallySpaced(
+        const reduced = xyEquallySpaced(
           { x, y: re },
           { numberOfPoints: 4096, zones },
         );
-        let result = baselineRegression(reduced.x, reduced.y, {
+        const result = baselineRegression(reduced.x, reduced.y, {
           regressionOptions: degree,
         });
-        let { regression } = result;
+        const { regression } = result;
         corrected = new Float64Array(x.length);
         for (let i = 0; i < re.length; i++) {
           corrected[i] = re[i] - regression.predict(x[i]);

package/src/datum/data1d/filter1d/digitalFilter.ts

@@ -33,8 +33,8 @@ export function apply(spectrum: Entry1DDigitalFilter, options: any = {}) {
     }
   }
 
-  let re = new Float64Array(spectrum.data.re);
-  let im = new Float64Array(spectrum.data.im);
+  const re = new Float64Array(spectrum.data.re);
+  const im = new Float64Array(spectrum.data.im);
 
   let pointsToShift = Math.floor(digitalFilterValue);
 

package/src/datum/data1d/filter1d/fft.ts

@@ -29,7 +29,7 @@ export function apply(datum1D: Entry1DFt) {
 
   checkSameLength(datum1D);
 
-  let digitalFilterApplied = datum1D.filters.some(
+  const digitalFilterApplied = datum1D.filters.some(
     (e) => e.name === 'digitalFilter' && e.flag,
   );
 
@@ -58,8 +58,8 @@ export function apply(datum1D: Entry1DFt) {
   );
 
   if (digitalFilterApplied) {
-    let { digitalFilter = 0 } = info;
-    let ph1 = (digitalFilter - Math.floor(digitalFilter)) * Math.PI * 2;
+    const { digitalFilter = 0 } = info;
+    const ph1 = (digitalFilter - Math.floor(digitalFilter)) * Math.PI * 2;
     Object.assign(
       data,
       reimPhaseCorrection(data as DataReIm, 0, -ph1, { reverse: true }),
@@ -90,10 +90,10 @@ function generateXAxis(datum1D: Entry1DFt) {
   const frequencyOffset = Number(info.frequencyOffset);
   const spectralWidth = Number(info.spectralWidth);
   const offset = frequencyOffset / baseFrequency;
-  let spectralHalfWidth = 0.5 * spectralWidth;
-  let nbPoints = datum1D.data.x.length;
+  const spectralHalfWidth = 0.5 * spectralWidth;
+  const nbPoints = datum1D.data.x.length;
   let firstPoint = offset - spectralHalfWidth;
-  let dx = spectralWidth / (nbPoints - 1);
+  const dx = spectralWidth / (nbPoints - 1);
   const xAxis = new Float64Array(nbPoints);
   for (let i = 0; i < nbPoints; i++) {
     xAxis[i] = firstPoint;
@@ -110,7 +110,7 @@ function removeDCOffset(
   spectrum: Partial<Entry1DFt> & { data: Required<NmrData1D> },
   digitalFilterApplied: boolean,
 ) {
-  let { digitalFilter = 0 } =
+  const { digitalFilter = 0 } =
     digitalFilterApplied && spectrum.info ? spectrum.info : {};
   const data = spectrum.data;
   const nbPoints = data.re.length;

package/src/datum/data1d/filter1d/phaseCorrection.ts

@@ -45,13 +45,13 @@ export function apply(datum1D: Entry1D, options: any = {}) {
       filter.value = { ...filter.value, ph0: 0, ph1: 0, absolute };
     }
   } else if ('ph0' in options && 'ph1' in options) {
-    let { ph0, ph1 } = options;
+    const { ph0, ph1 } = options;
     phaseCorrection(datum1D, { ph0, ph1 });
     if (filter) {
       filter.value = { ...filter.value, absolute };
     }
   } else {
-    let { ph0, ph1 } = autoPhaseCorrection(datum1D);
+    const { ph0, ph1 } = autoPhaseCorrection(datum1D);
     phaseCorrection(datum1D, { ph0, ph1 });
     if (filter) {
       filter.value = { ...filter.value, absolute, ph0, ph1 };
@@ -63,7 +63,7 @@ function phaseCorrection(
   spectrum: Entry1D & { data: Required<NmrData1D> },
   phaseValues: { ph0: number; ph1: number },
 ) {
-  let { ph0, ph1 } = phaseValues;
+  const { ph0, ph1 } = phaseValues;
   const { re, im } = spectrum.data;
   const phased = reimPhaseCorrection(
     { re, im },

package/src/datum/data1d/filter1d/signalProcessing.ts

@@ -33,7 +33,7 @@ export function reduce(previousValue: any, newValue: any) {
 
 export function filterXY(spectrum: Entry1D, options: MatrixOptions) {
   let x = spectrum.data.x.slice(0);
-  let cloneX = spectrum.data.x.slice(0);
+  const cloneX = spectrum.data.x.slice(0);
   let re = spectrum.data.re.slice(0);
   let im = spectrum.data.im?.slice(0);
 

package/src/datum/data1d/filter1d/utils/padDataToNextPowerOfTwo.ts

@@ -14,8 +14,8 @@ export function padDataToNextPowerOfTwo(
   const { x, re, im } = datum1D.data;
   const size = nextPowerOfTwo(x.length);
 
-  let newRE = new Float64Array(size);
-  let newIM = new Float64Array(size);
+  const newRE = new Float64Array(size);
+  const newIM = new Float64Array(size);
 
   const grpdly = datum1D.info?.digitalFilter || 0;
   const pointsToShift = grpdly > 0 ? Math.floor(grpdly) : 0;

package/src/datum/data1d/filter1d/zeroFilling.ts

@@ -27,17 +27,18 @@ export function apply(
     throw new Error('zeroFilling not applicable on this data');
   }
 
-  let { nbPoints, factor = 2 } = options;
-
-  if (!nbPoints) {
-    nbPoints = 2 ** Math.round(Math.log2(datum1D.data.x.length * factor));
+  const { factor = 2 } = options;
+  const {
+    nbPoints = 2 ** Math.round(Math.log2(datum1D.data.x.length * factor)),
+  } = options;
+  if (!options.nbPoints) {
     const filter = datum1D.filters.find((filter) => filter.name === id);
     if (filter) {
       filter.value = { nbPoints };
     }
   }
 
-  let digitalFilterApplied = datum1D.filters.some(
+  const digitalFilterApplied = datum1D.filters.some(
     (e) => e.name === 'digitalFilter' && e.flag,
   );
 
@@ -47,9 +48,9 @@ export function apply(
 
   const { re, im, x } = datum1D.data;
 
-  let newRE = new Float64Array(nbPoints);
-  let newIM = new Float64Array(nbPoints);
-  let newX = new Float64Array(nbPoints);
+  const newRE = new Float64Array(nbPoints);
+  const newIM = new Float64Array(nbPoints);
+  const newX = new Float64Array(nbPoints);
 
   const length = Math.min(nbPoints, re.length);
 
@@ -57,7 +58,7 @@ export function apply(
   newIM.set(im.slice(0, length - pointsToShift));
   newX.set(x.slice(0, length - pointsToShift));
 
-  let diff = x[1] - x[0];
+  const diff = x[1] - x[0];
   let currentX = x[length - pointsToShift - 1];
   for (let i = length - pointsToShift; i < nbPoints; i++) {
     currentX += diff;

package/src/datum/data1d/utils/mapPeaks.ts

@@ -41,7 +41,7 @@ export function mapPeaks(
   const shiftX = getShiftX(spectrum);
   const error = getSpectrumErrorValue(spectrum);
 
-  let newPeaks: Peak1D[] = [];
+  const newPeaks: Peak1D[] = [];
 
   for (const peak of peaks) {
     const peakDelta = getPeakDelta(peak, shiftTarget, shiftX);

package/src/datum/data2d/Entry2D.ts

@@ -10,5 +10,5 @@ export interface Entry2D {
   originalInfo?: Record<string, any>;
   data: NmrData2D;
   originalData?: NmrData2D;
-  filters: Array<Filter>;
+  filters: Filter[];
 }

package/src/datum/data2d/filter2d/fftDimension1.ts

@@ -0,0 +1,61 @@
+import { NmrData2DFid } from 'cheminfo-types';
+import { FilterDomainUpdateRules } from '../../FiltersManager';
+import { Entry2D } from '../Entry2D';
+import { quadrature } from '../../../xyz/quadrature';
+import {
+  DirectDimensionOptions,
+  fftDirectDimension,
+} from '../../../xyz/util/fft2d/fftDirectDimension';
+import { xEnsureFloat64 } from 'ml-spectra-processing';
+
+export const id = 'fftDimension1';
+export const name = 'FFT Dimension 1';
+
+export const DOMAIN_UPDATE_RULES: Readonly<FilterDomainUpdateRules> = {
+  updateXDomain: true,
+  updateYDomain: true,
+};
+
+export function apply(datum2D: Entry2D, options: DirectDimensionOptions) {
+  if (!isApplicable(datum2D)) {
+    throw new Error('fft dimension 1 not applicable on this data');
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const { data, info } = datum2D;
+  const { digitalFilterValue = 0 } = info;
+
+  const fnMode = info.fnMode[1];
+  const { zeroFilling = {} } = options;
+  const orderedData = quadrature(data, { fnMode });
+
+  const nbColumns = orderedData.re[0].length;
+
+  const { factor = 1 } = zeroFilling;
+  const nbPoints =
+    zeroFilling?.nbPoints || 2 ** Math.round(Math.log2(nbColumns * factor));
+
+  const transformed = fftDirectDimension(orderedData, {
+    fnMode,
+    ...options,
+    digitalFilterValue,
+    zeroFilling: { nbPoints },
+  });
+
+  datum2D.data.re.z = transformed.re.to2DArray().map(xEnsureFloat64);
+  datum2D.data.im.z = transformed.im.to2DArray().map(xEnsureFloat64);
+}
+
+export function isApplicable(
+  datum2D: Entry2D,
+): datum2D is Entry2D & { data: Required<NmrData2DFid> } {
+  if (datum2D.info.isComplex && datum2D.info.isFid) return true;
+  return false;
+}
+
+export function reduce() {
+  return {
+    once: true,
+    reduce: undefined,
+  };
+}

package/src/datum/data2d/filter2d/fftDimension2.ts

@@ -0,0 +1,72 @@
+import { NmrData2DFid, NmrData2DFt } from 'cheminfo-types';
+import { FilterDomainUpdateRules } from '../../FiltersManager';
+import { Entry2D } from '../Entry2D';
+import {
+  IndirectDimensionOptions,
+  fftIndirectDimension,
+} from '../../../xyz/util/fft2d/fftIndirectDimension';
+import { xEnsureFloat64 } from 'ml-spectra-processing';
+import { getMinMaxXY } from '../../../xyz/util/getMinMaxXY';
+
+export const id = 'fftDimension2';
+export const name = 'FFT Dimension 2';
+
+export const DOMAIN_UPDATE_RULES: Readonly<FilterDomainUpdateRules> = {
+  updateXDomain: true,
+  updateYDomain: true,
+};
+
+export function apply(datum2D: Entry2D, options: IndirectDimensionOptions) {
+  if (!isApplicable(datum2D)) {
+    throw new Error('fft dimension 2 not applicable on this data');
+  }
+  const { data, info } = datum2D;
+  const fnMode = info.fnMode[1];
+  const { zeroFilling = {} } = options;
+  const nbRows = data.re.z.length;
+  const { factor = 1 } = zeroFilling;
+  const nbPoints =
+    zeroFilling?.nbPoints || 2 ** Math.round(Math.log2(nbRows * factor));
+
+  const transformed = fftIndirectDimension(
+    {
+      re: data.re.z,
+      im: data.im.z,
+    },
+    {
+      fnMode,
+      ...options,
+      zeroFilling: { nbPoints },
+    },
+  );
+
+  const minMaxXY = getMinMaxXY(info);
+
+  (datum2D.data as NmrData2DFt) = {
+    rr: {
+      z: transformed.re.to2DArray().map(xEnsureFloat64),
+      maxZ: transformed.re.max(),
+      minZ: transformed.re.min(),
+      ...minMaxXY,
+    },
+  };
+  const { isFid, isComplex, ...resInfo } = info;
+  datum2D.info = {
+    ...resInfo,
+    isFt: true,
+  };
+}
+
+export function isApplicable(
+  datum2D: Entry2D,
+): datum2D is Entry2D & { data: Required<NmrData2DFid> } {
+  if (datum2D.info.isComplex && datum2D.info.isFid) return true;
+  return false;
+}
+
+export function reduce() {
+  return {
+    once: true,
+    reduce: undefined,
+  };
+}

package/src/datum/data2d/utils/getShift.ts

@@ -7,7 +7,7 @@ export interface Shift2D {
 }
 
 export function getShift(spectrum: Entry2D): Shift2D {
-  let shift = { x: 0, y: 0 };
+  const shift = { x: 0, y: 0 };
   if (spectrum?.filters) {
     for (const filter of spectrum.filters) {
       if (filter.name === Filters.shift2DX.id) {