nmr-processing 9.7.8 → 9.8.0

package/src/assignment/utils/{getAssignment → generalAssignment}/createMapPossibleAssignment.ts

@@ -1,6 +1,6 @@
 import { getCorrelationDelta } from 'nmr-correlation';
 
-import { PossibleAssignmentMap } from '../createMapPossibleAssignments';
+import { PossibleAssignmentMap } from '../oneDimensionalAssignment/createMapPossibleAssignments';
 
 import {
   AtomTypes,
@@ -9,12 +9,8 @@ import {
 } from './buildAssignments';
 import { TargetsByAtomType } from './getTargetsAndCorrelations';
 
-export interface PossibleAssignments {
-  [key: string]: string[];
-}
-export interface MapPossibleAssignments {
-  [key: string]: PossibleAssignmentMap;
-}
+export type PossibleAssignments = Record<string, string[]>;
+export type MapPossibleAssignments = Record<string, PossibleAssignmentMap>;
 export interface CreateMapPossibleAssignmentOptions {
   restrictionByCS: RestrictionByCS;
   predictions: PredictionsByAtomType;
@@ -31,17 +27,17 @@ export function createMapPossibleAssignment(
   const atomTypes = Object.keys(predictions) as AtomTypes[];
 
   for (const atomType of atomTypes) {
-    let errorAbs = toleranceCS[atomType];
-    let predictionByAtomType = predictions[atomType];
-    let targetByAtomType = targets[atomType];
+    const errorAbs = toleranceCS[atomType];
+    const predictionByAtomType = predictions[atomType];
+    const targetByAtomType = targets[atomType];
     if (!expandMap[atomType]) expandMap[atomType] = {};
     for (const diaID in predictionByAtomType) {
-      let prediction = predictionByAtomType[diaID];
+      const prediction = predictionByAtomType[diaID];
       expandMap[atomType][diaID] = [];
 
       if (targetByAtomType) {
         for (const targetID in targetByAtomType) {
-          let target = targetByAtomType[targetID];
+          const target = targetByAtomType[targetID];
           const { nbAtoms, protonsCount: protonsCountFromPrediction } =
             prediction;
           const { integration, protonsCount } = target;
@@ -63,11 +59,11 @@ export function createMapPossibleAssignment(
               // Chemical shift is not a restriction
               expandMap[atomType][diaID].push(targetID);
             } else {
-              let targetDelta = getCorrelationDelta(target);
+              const targetDelta = getCorrelationDelta(target);
               if (targetDelta === undefined) {
                 throw new Error(`Correlation has not delta`);
               }
-              let distAfterLimit = Math.abs(
+              const distAfterLimit = Math.abs(
                 prediction.delta - targetDelta - errorAbs,
               );
 

package/src/assignment/utils/{getAssignment → generalAssignment}/exploreTree.ts

@@ -1,4 +1,4 @@
-import { StoreAssignments } from '../buildAssignments';
+import { StoreAssignments } from '../oneDimensionalAssignment/buildAssignments';
 
 import {
   RestrictionByCS,
@@ -73,10 +73,10 @@ export function exploreTree(
     const diaID = diaIDPeerPossibleAssignment[atomType][currentIndex];
     const possibleAssignments = possibleAssignmentMap[atomType][diaID];
 
-    for (let targetID of possibleAssignments) {
+    for (const targetID of possibleAssignments) {
       partial[atomType][currentIndex] = targetID;
 
-      let score = partialScore(partial, {
+      const score = partialScore(partial, {
         diaIDPeerPossibleAssignment,
         infoByAtomTypes,
         restrictionByCS,
@@ -126,11 +126,10 @@ export interface AssignmentSolution {
 }
 
 function addSolution(store: StoreAssignments, props: AddSolutionOptions) {
-  let { score, maxSolutions, partial, predictions } = props;
-  score /= doubleAssignmentPenalty(partial, predictions);
-  let solution: AssignmentSolution = {
+  const { score, maxSolutions, partial, predictions } = props;
+  const solution: AssignmentSolution = {
     assignment: JSON.parse(JSON.stringify(partial)),
-    score,
+    score: score / doubleAssignmentPenalty(partial, predictions),
   };
 
   if (store.nSolutions >= maxSolutions) {
@@ -163,7 +162,7 @@ function doubleAssignmentPenalty(
   let nbDoubleAssignment = 0;
   for (const atomType in predictions) {
     const nbSources = Object.keys(predictions[atomType]).length;
-    let assignments = new Set(partial[atomType]);
+    const assignments = new Set(partial[atomType]);
     nbDoubleAssignment += nbSources - assignments.size;
   }
   return nbDoubleAssignment > 0 ? 2 * nbDoubleAssignment : 1;

package/src/assignment/utils/{getAssignment → generalAssignment}/formatData.ts

@@ -22,8 +22,8 @@ export type SpectraDataFormatted =
 export function formatData(
   input: SpectraDataWithIds[] = [],
 ): SpectraDataFormatted[] {
-  let inputClone = JSON.parse(JSON.stringify(input)) as SpectraDataWithIds[];
-  let spectra: SpectraDataFormatted[] = [];
+  const inputClone = JSON.parse(JSON.stringify(input)) as SpectraDataWithIds[];
+  const spectra: SpectraDataFormatted[] = [];
   for (const spectraData of inputClone) {
     const { id, info } = spectraData;
     if (isSpectraData1D(spectraData)) {
@@ -43,12 +43,12 @@ export function formatData(
 function rescaleIntegration(spectrum: SpectraData1DWithIds): NMRRangeWithIds[] {
   if (spectrum.info.nucleus !== '1H') return spectrum.ranges;
 
-  let totalIntegration = spectrum.ranges.reduce(
+  const totalIntegration = spectrum.ranges.reduce(
     (total, range) => (range.integration ? total + range.integration : total),
     0,
   );
 
-  for (let range of spectrum.ranges) {
+  for (const range of spectrum.ranges) {
     if (range.integration) {
       range.integration *= 100 / totalIntegration;
       if (range.signals) {
@@ -57,7 +57,7 @@ function rescaleIntegration(spectrum: SpectraData1DWithIds): NMRRangeWithIds[] {
             signal.integration ? total + signal.integration : total,
           0,
         );
-        for (let signal of range.signals) {
+        for (const signal of range.signals) {
           if (signal.integration) {
             signal.integration *= range.integration / totalSignalIntegration;
           } else {

package/src/assignment/utils/{getAssignment → generalAssignment}/getTargetsAndCorrelations.ts

@@ -12,11 +12,9 @@ export interface CorrelationWithIntegration
     'link' | 'atomType' | 'label' | 'attachment' | 'protonsCount'
   > {
   integration: number;
-  indirectLinks: Array<Link>;
-}
-export interface Targets {
-  [key: string]: CorrelationWithIntegration;
+  indirectLinks: Link[];
 }
+export type Targets = Record<string, CorrelationWithIntegration>;
 export interface TargetsByAtomType {
   H: Targets;
   C: Targets;
@@ -40,7 +38,7 @@ export function getTargetsAndCorrelations(
     tolerance,
   });
 
-  let targets: any = {};
+  const targets: any = {};
   for (const correlation of correlations) {
     if (correlation.pseudo) continue;
     const { id: targetID, atomType } = correlation;

package/src/assignment/utils/{getAssignment → generalAssignment}/getWorkFlow.ts

@@ -8,10 +8,7 @@ import { AtomTypes } from './buildAssignments';
  * @param {*} justAssign
  */
 
-function getWorkFlow(
-  correlations: Values,
-  justAssign: Array<AtomTypes[]> = [],
-) {
+function getWorkFlow(correlations: Values, justAssign: AtomTypes[][] = []) {
   const experimentTypes = extractExperimentType(correlations);
 
   const { hasHSQC, types } = experimentTypes;
@@ -20,7 +17,7 @@ function getWorkFlow(
     return { assignmentOrder: justAssign, experimentTypes };
   }
 
-  const assignmentOrder: Array<AtomTypes[]> = [];
+  const assignmentOrder: AtomTypes[][] = [];
 
   if (hasHSQC) {
     assignmentOrder.push(['C'], ['H']);

package/src/assignment/utils/{getAssignment → generalAssignment}/groupCarbonTargetByIntegrationZone.ts

@@ -8,27 +8,27 @@ function groupCarbonTargetByIntegrationZone(
   targets: Targets,
   correlations: CorrelationWithIntegration[],
 ) {
-  let targetID = activeDomainOnTarget[0];
-  let { H: attachments = [] } = targets[targetID].attachment;
+  const targetID = activeDomainOnTarget[0];
+  const { H: attachments = [] } = targets[targetID].attachment;
 
-  let targetByIntegral = [
+  const targetByIntegral = [
     { targetIDs: [targetID], attachments: new Set<number>(attachments) },
   ];
 
   for (let i = 1; i < activeDomainOnTarget.length; i++) {
-    let targetID = activeDomainOnTarget[i];
-    let target = targets[targetID];
-    let { H: attachments = [] } = target.attachment;
+    const targetID = activeDomainOnTarget[i];
+    const target = targets[targetID];
+    const { H: attachments = [] } = target.attachment;
 
     let alone = true;
-    for (let group of targetByIntegral) {
+    for (const group of targetByIntegral) {
       const pertain = attachments.some((attachment: any) =>
         group.attachments.has(attachment),
       );
       if (pertain) {
         alone = false;
         group.targetIDs.push(targetID);
-        for (let attachment of attachments) {
+        for (const attachment of attachments) {
           group.attachments.add(attachment);
         }
         break;

package/src/assignment/utils/{getAssignment → generalAssignment}/partialScore.ts

@@ -14,7 +14,7 @@ import {
 import groupCarbonTargetByIntegrationZone from './groupCarbonTargetByIntegrationZone';
 
 export interface PartialScoreOptions {
-  diaIDPeerPossibleAssignment: { [key: string]: string[] };
+  diaIDPeerPossibleAssignment: Record<string, string[]>;
   restrictionByCS: RestrictionByCS;
   infoByAtomTypes: InfoByAtomType;
   correlations: CorrelationWithIntegration[];
@@ -22,13 +22,9 @@ export interface PartialScoreOptions {
   targets: TargetsByAtomType;
 }
 
-interface ObjectStringArray {
-  [key: string]: string[];
-}
+type ObjectStringArray = Record<string, string[]>;
 
-interface ObjectObjectStringArray {
-  [key: string]: ObjectStringArray;
-}
+type ObjectObjectStringArray = Record<string, ObjectStringArray>;
 
 export function partialScore(partial: Partial, props: PartialScoreOptions) {
   const {
@@ -43,8 +39,8 @@ export function partialScore(partial: Partial, props: PartialScoreOptions) {
   const { tolerance: toleranceCS, useChemicalShiftScore } = restrictionByCS;
   let totalStarts = 0;
   let totalPartial = 0;
-  let partialInverse: ObjectObjectStringArray = {};
-  let activeDomainOnPrediction: { [key: string]: number[] } = {};
+  const partialInverse: ObjectObjectStringArray = {};
+  const activeDomainOnPrediction: Record<string, number[]> = {};
   const atomTypes = Object.keys(partial) as AtomTypes[];
   for (const atomType of atomTypes) {
     let countStars = 0;
@@ -89,11 +85,11 @@ export function partialScore(partial: Partial, props: PartialScoreOptions) {
 
   const getPredictionByDiaID = getPrediction.bind({}, predictions);
   // check the integration
-  const targetByIntegral: {
+  const targetByIntegral: Array<{
     atomType: string;
     targetIDs: string[];
     integration: number;
-  }[] = [];
+  }> = [];
 
   for (const atomType in partial) {
     if (atomType === 'C' && activeDomainOnTarget[atomType].length > 0) {
@@ -105,7 +101,7 @@ export function partialScore(partial: Partial, props: PartialScoreOptions) {
         ),
       );
     } else {
-      for (let targetID of activeDomainOnTarget[atomType]) {
+      for (const targetID of activeDomainOnTarget[atomType]) {
         targetByIntegral.push({
           atomType,
           targetIDs: [targetID],
@@ -120,8 +116,8 @@ export function partialScore(partial: Partial, props: PartialScoreOptions) {
     if (integration === undefined || isNaN(integration)) continue;
 
     let total = 0;
-    for (let targetID of group.targetIDs) {
-      let targetToSource = partialInverse[atomType][targetID];
+    for (const targetID of group.targetIDs) {
+      const targetToSource = partialInverse[atomType][targetID];
       for (const diaID of targetToSource) {
         const { prediction, atomType: atomOfPrediction } =
           getPredictionByDiaID(diaID);
@@ -146,10 +142,10 @@ export function partialScore(partial: Partial, props: PartialScoreOptions) {
         const targetID = partialPeerAtomType[index];
         if (targetID && targetID !== '*') {
           count++;
-          let diaID = diaIDPeerPossibleAssignment[atomType][index];
-          let source = predictions[atomType][diaID];
-          let target = targetsPeerAtomType[targetID];
-          let error = toleranceCS[atomType];
+          const diaID = diaIDPeerPossibleAssignment[atomType][index];
+          const source = predictions[atomType][diaID];
+          const target = targetsPeerAtomType[targetID];
+          const error = toleranceCS[atomType];
           // if (source.error) {
           //   error = Math.max(source.error, toleranceCS);
           // }
@@ -183,7 +179,7 @@ export function partialScore(partial: Partial, props: PartialScoreOptions) {
   let scoreOn2D = 0;
 
   if (howManyActived(activeDomainOnTarget) > 1) {
-    let andConstrains: { [key: string]: number } = {};
+    const andConstrains: Record<string, number> = {};
     let activeDomain: Array<{ index: number; atomType: AtomTypes }> = [];
 
     for (const atomType of Object.keys(
@@ -204,20 +200,20 @@ export function partialScore(partial: Partial, props: PartialScoreOptions) {
           predictions[atomTypeJ][
             diaIDPeerPossibleAssignment[atomTypeJ][indexJ]
           ];
-        let pathLength = predictionI.pathLength[predictionJ.diaIDIndex];
-        let isPossible = pathLength < 5;
+        const pathLength = predictionI.pathLength[predictionJ.diaIDIndex];
+        const isPossible = pathLength < 5;
 
-        let partialI = partial[atomTypeI][indexI];
-        let partialJ = partial[atomTypeJ][indexJ];
+        const partialI = partial[atomTypeI][indexI];
+        const partialJ = partial[atomTypeJ][indexJ];
 
         if (!partialI || !partialJ) continue;
 
-        let keyOnTargertMap =
+        const keyOnTargertMap =
           partialI > partialJ
             ? `${partialJ} ${partialI}`
             : `${partialI} ${partialJ}`;
 
-        let areLinked = checkLinking(
+        const areLinked = checkLinking(
           {
             from: {
               targetID: partialI,
@@ -231,7 +227,7 @@ export function partialScore(partial: Partial, props: PartialScoreOptions) {
           targets,
         );
 
-        let partialScore2D = isPossible
+        const partialScore2D = isPossible
           ? areLinked
             ? 1
             : 0
@@ -246,7 +242,7 @@ export function partialScore(partial: Partial, props: PartialScoreOptions) {
     }
 
     let sumAnd = 0;
-    for (let key in andConstrains) {
+    for (const key in andConstrains) {
       sumAnd += andConstrains[key];
     }
 
@@ -277,8 +273,8 @@ function checkLinking(
 ) {
   const { from, to } = partials;
   if (from.targetID === to.targetID) return true;
-  let correlationI = correlations[from.atomType][from.targetID];
-  let correlationJ = correlations[to.atomType][to.targetID];
+  const correlationI = correlations[from.atomType][from.targetID];
+  const correlationJ = correlations[to.atomType][to.targetID];
   for (const linkJ of correlationJ.link) {
     for (const link of correlationI.link) {
       if (link.signal.id === linkJ.signal.id) return true;

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/degreeToRadians.ts

@@ -0,0 +1 @@
+export const degreeToRadians = Math.PI / 180;

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,