react-science 0.19.1

package/src/app-data/loaders/biologicLoader.ts

@@ -0,0 +1,161 @@
+import { parseMPR, parseMPT } from 'biologic-converter';
+import type { MeasurementVariable } from 'cheminfo-types';
+import type { FileCollection } from 'filelist-utils';
+
+import type { Measurements, MeasurementBase } from '../index';
+
+import { getMeasurementInfoFromFile } from './utility/getMeasurementInfoFromFile';
+import { createLogEntry, ParserLog } from './utility/parserLog';
+
+/* the MeasurementBase has got a data key,
+ and inside a variable key, compatible with this type */
+type MeasurementDataVariable = Record<string, MeasurementVariable>;
+/**
+ *
+ * @param fileCollection - the dragged file/files
+ * @param logs - pass to append errors to the logs, it mutates the external array.
+ * @returns - new measurements object to be merged
+ */
+export async function biologicLoader(
+  fileCollection: FileCollection,
+  logs?: ParserLog[],
+): Promise<Partial<Measurements>> {
+  const measurements: Partial<Measurements> = {};
+  const entries: MeasurementBase[] = [];
+
+  for (const file of fileCollection.files) {
+    try {
+      if (/\.mpr$/i.test(file.name)) {
+        const mpr = parseMPR(await file.arrayBuffer());
+        const meta = mpr.settings.variables;
+        const info = getMeasurementInfoFromFile(
+          file,
+          `Experiment: ${meta.technique}`,
+        );
+        // puts the "useful" variables at x and y for default plot.
+        const variables = preferredXY(meta.technique, mpr.data.variables);
+        const result: MeasurementBase = {
+          ...info,
+          meta,
+          data: [{ variables }],
+        };
+        entries.push(result);
+      } else if (/\.mpt$/i.test(file.name)) {
+        const { data, settings } = parseMPT(await file.arrayBuffer());
+        if (data.variables) {
+          const metaData = settings?.variables;
+          const info = getMeasurementInfoFromFile(
+            file,
+            metaData?.technique
+              ? `Experiment: ${metaData.technique}`
+              : file.name,
+          );
+          // puts the "useful" variables at x and y for default plot.
+          const variables = preferredXY(metaData?.technique, data.variables);
+          const result: MeasurementBase = {
+            ...info,
+            meta: metaData || {},
+            data: [{ variables }],
+          };
+          entries.push(result);
+        }
+      }
+    } catch (error) {
+      //send error to UI to show to User ?
+      if (error instanceof Error) {
+        if (logs) {
+          logs.push(createLogEntry({ error, relativePath: file.relativePath }));
+        } else {
+          throw error;
+        }
+      }
+    }
+  }
+  measurements.iv = { entries };
+  return measurements;
+}
+
+/**
+ * Each biologic experiment stores measurement variables (not just `x` and `y`) in the
+ * `data.variables` object.
+ * this function takes "useful ones", and place them as `x` and `y`.
+ * so they are default for the plot.
+ * @param technique technique used in the experiment
+ * @param variables experiment variables
+ * @returns the same data (and type) with rearranged variables.
+ * (does not need return type as it is inferred)
+ */
+function preferredXY(
+  technique: string | undefined,
+  variables: MeasurementDataVariable,
+) {
+  if (!technique) return variables;
+
+  switch (technique) {
+    case 'CA': {
+      //Chronoamperometry or Chronocoulometry (distinguish?)
+      variables = setDefault(variables, 'I', 'y');
+      variables = setDefault(variables, 'time', 'x');
+      break;
+    }
+    case 'CP': {
+      //Chronopotentiometry. <average>
+      variables = setDefault(variables, '<Ewe>', 'y');
+      variables = setDefault(variables, 'time', 'x');
+      break;
+    }
+    case 'CV': {
+      //cyclic voltammetry. <average>
+      variables = setDefault(variables, '<I>', 'y');
+      variables = setDefault(variables, 'Ewe', 'x');
+      break;
+    }
+    case 'GCPL': {
+      variables = setDefault(variables, 'Ewe', 'y');
+      variables = setDefault(variables, 'time', 'x');
+      break;
+    }
+    case 'OCV': {
+      variables = setDefault(variables, 'Ewe', 'y');
+      variables = setDefault(variables, 'time', 'x');
+      break;
+    }
+    default:
+      break;
+  }
+  return variables;
+}
+/**
+ * Stores object with "label" at either "x" or "y".
+ * the data stored is still the same.
+ * @param variables experimental variables
+ * @param label label to search for in the variables object (time, potential, current, etc)
+ * @param storeAt which key to move that data to
+ * @returns the new variables object.
+ */
+function setDefault(
+  variables: MeasurementDataVariable,
+  label: string,
+  storeAt: 'x' | 'y',
+) {
+  for (const varum in variables) {
+    // find the key with `label` (or skip if not found)
+    if (
+      variables[varum].label === label && //if not already at the right key
+      varum !== storeAt
+    ) {
+      // populate key, if there is no data there.
+      if (!variables[storeAt]) {
+        variables[storeAt] = variables[varum];
+        delete variables[varum];
+      } else {
+        // if the storeAt is already occupied, swap the two
+        const originalX = variables[storeAt];
+        const newX = variables[varum];
+        variables[storeAt] = newX;
+        variables[varum] = originalX;
+      }
+    }
+  }
+  return variables;
+}

package/src/app-data/loaders/cdfLoader.ts

@@ -0,0 +1,200 @@
+import type { FileCollection } from 'filelist-utils';
+// @ts-expect-error netcdfjs has no types at the moment.
+import { NetCDFReader } from 'netcdfjs';
+
+import { assert } from '../../components/index';
+import type { MeasurementBase, Measurements, MeasurementKind } from '../index';
+
+import { getMeasurementInfoFromFile } from './utility/getMeasurementInfoFromFile';
+import { ParserLog, createLogEntry } from './utility/parserLog';
+
+export async function cdfLoader(
+  fileCollection: FileCollection,
+  logs?: ParserLog[],
+): Promise<Partial<Measurements>> {
+  const newMeasurements: Partial<Measurements> = {};
+  let kind: MeasurementKind | undefined;
+  for (const file of fileCollection) {
+    if (/\.cdf$/i.test(file.name)) {
+      try {
+        const reader = new NetCDFReader(await file.arrayBuffer(), {
+          meta: true,
+        });
+
+        if (
+          reader.dataVariableExists('mass_values') &&
+          reader.dataVariableExists('time_values')
+        ) {
+          kind = 'gclcms';
+        } else if (
+          reader.dataVariableExists('ordinate_values') &&
+          reader.getAttribute('detector_name') &&
+          reader.getAttribute('detector_name').match(/dad|tic/i)
+        ) {
+          kind = 'gclc';
+        } else {
+          return newMeasurements;
+        }
+
+        addMeta(reader, reader.globalAttributes);
+        if (!newMeasurements[kind]) {
+          newMeasurements[kind] = { entries: [] };
+        }
+        assert(
+          newMeasurements[kind],
+          'Error while loading, kind is not defined',
+        );
+        const newMeasurement = {
+          ...getMeasurementInfoFromFile(
+            file,
+            reader.getAttribute('experiment_title'),
+          ),
+          meta: reader.header.meta,
+          data:
+            kind === 'gclcms'
+              ? chromatogramWithMassSpectra(reader)
+              : chromatogram(reader),
+        };
+        newMeasurements[kind]?.entries.push(newMeasurement);
+      } catch (error) {
+        if (error instanceof Error) {
+          //send error to UI ?
+          if (logs) {
+            logs.push(
+              createLogEntry({
+                error,
+                parser: 'cdfLoader',
+                message: 'error parsing file from cdfLoader',
+                relativePath: file.relativePath,
+              }),
+            );
+          } else {
+            throw error;
+          }
+        }
+      }
+    }
+  }
+
+  return newMeasurements;
+}
+
+function chromatogramWithMassSpectra(
+  reader: NetCDFReader,
+): MeasurementBase['data'] {
+  // Taken from: https://github.com/cheminfo/netcdf-gcms
+  const pointCount = reader.getDataVariable('point_count');
+  const massValues = reader.getDataVariable('mass_values');
+  const intensityValues = reader.getDataVariable('intensity_values');
+  const times = reader.getDataVariable('scan_acquisition_time');
+  const tics = reader.getDataVariable('total_intensity');
+
+  let index = 0;
+  const allMasses: Float64Array[] = [];
+  const allIntensities: Float64Array[] = [];
+  for (const size of pointCount) {
+    const masses = new Float64Array(size);
+    const intensities = new Float64Array(size);
+    for (let j = 0; j < size; j++) {
+      masses[j] = massValues[index];
+      intensities[j] = intensityValues[index++];
+    }
+    allIntensities.push(intensities);
+    allMasses.push(masses);
+  }
+  let data: MeasurementBase['data'] = [];
+  for (let i = 0; i < times.length; i++) {
+    data.push({
+      info: {
+        time: { value: times[i], units: 's' },
+        tic: tics[i],
+      },
+      variables: {
+        x: {
+          symbol: 'X',
+          label: 'm/z',
+          units: '',
+          data: allMasses[i] || [],
+        },
+        y: {
+          symbol: 'Y',
+          label: 'relative intensity',
+          units: '',
+          data: allIntensities[i] || [],
+        },
+      },
+    });
+  }
+  return data;
+}
+
+function chromatogram(reader: NetCDFReader): MeasurementBase['data'] {
+  // Taken from: https://github.com/cheminfo/netcdf-gcms
+  let data: MeasurementBase['data'] = [];
+  const intensities: number[] = reader.getDataVariable('ordinate_values');
+  const numberPoints = intensities.length;
+  const detector: string = reader.getAttribute('detector_name');
+  let channel: string;
+  if (/dad/i.test(detector)) {
+    const uvNumber = detector.match(/.*Sig=(?<uvNumber>\d+).*/)?.groups
+      ?.uvNumber;
+    channel = `uv${Number(uvNumber) || ''}`;
+  } else if (/tic/i.test(detector)) {
+    channel = 'tic';
+  } else {
+    channel = 'unknown';
+  }
+  const delayTime: number = reader.getDataVariable('actual_delay_time')[0];
+  const runtimeLength: number = reader.getDataVariable(
+    'actual_run_time_length',
+  )[0];
+  let samplingInterval;
+  if (reader.dataVariableExists('actual_sampling_interval')) {
+    samplingInterval = reader.getDataVariable('actual_sampling_interval')[0];
+
+    if (
+      Math.abs(delayTime + samplingInterval * numberPoints - runtimeLength) > 3
+    ) {
+      throw new Error(
+        'The expected last time does not correspond to the runtimeLength',
+      );
+    }
+  } else {
+    samplingInterval = (runtimeLength - delayTime) / numberPoints;
+  }
+
+  let times: number[] = [];
+  let time = delayTime;
+  for (let i = 0; i < numberPoints; i++) {
+    times.push(time);
+    time += samplingInterval;
+  }
+
+  data.push({
+    variables: {
+      x: {
+        symbol: 'X',
+        label: 'time',
+        units: 's',
+        data: times || [],
+      },
+      y: {
+        symbol: 'Y',
+        label: channel,
+        units: '',
+        data: intensities || [],
+      },
+    },
+  });
+  return data;
+}
+
+function addMeta(
+  reader: NetCDFReader,
+  globalAttributes: NetCDFReader.globalAttributes,
+) {
+  reader.header.meta = {};
+  for (const item of globalAttributes) {
+    reader.header.meta[item.name] = item.value;
+  }
+}

package/src/app-data/loaders/index.ts

@@ -0,0 +1,8 @@
+export * from './proprietary/agilent/cary500Loader';
+export * from './utility/index';
+export * from './biologicLoader';
+export * from './cdfLoader';
+export * from './jcampLoader';
+export * from './loadMeasurements';
+export * from './spcLoader';
+export * from './wdfLoader';

package/src/app-data/loaders/jcampLoader.ts

@@ -0,0 +1,107 @@
+import type { FileCollection } from 'filelist-utils';
+import { convert } from 'jcampconverter';
+
+import { assert } from '../../components/index';
+import type { MeasurementKind, Measurements } from '../index';
+
+import { getMeasurementInfoFromFile } from './utility/getMeasurementInfoFromFile';
+import { createLogEntry, ParserLog } from './utility/parserLog';
+
+/**
+ *
+ * @param fileCollection - the dragged file/files
+ * @param logger - whether to log to console or not
+ * @returns - new measurements object to be merged
+ */
+export async function jcampLoader(
+  fileCollection: FileCollection,
+  logs?: ParserLog[],
+): Promise<Partial<Measurements>> {
+  const newMeasurements: Partial<Measurements> = {};
+  for (const file of fileCollection) {
+    if (/(?:\.jdx|\.dx)$/i.test(file.name)) {
+      try {
+        const parsed = convert(await file.text(), { keepRecordsRegExp: /.*/ });
+        for (const measurement of parsed.flatten) {
+          let kind: MeasurementKind | undefined;
+          if (measurement?.dataType?.match(/infrared|ir/i)) {
+            kind = 'ir';
+          } else if (measurement?.dataType?.match(/raman/i)) {
+            kind = 'raman';
+          } else if (measurement?.dataType?.match(/uv/i)) {
+            kind = 'uv';
+          } else if (measurement?.dataType?.match(/mass/i)) {
+            kind = 'mass';
+          } else if (measurement?.dataType?.match(/nmr/i)) {
+            kind = 'nmr';
+          }
+          if (kind) {
+            if (!newMeasurements[kind]) {
+              newMeasurements[kind] = { entries: [] };
+            }
+            assert(
+              newMeasurements[kind],
+              'Error while loading, kind is not defined',
+            );
+            const newMeasurement = {
+              ...getMeasurementInfoFromFile(file, measurement.title || ''),
+              meta: measurement.meta,
+              data: normalizeSpectra(measurement.spectra),
+            };
+            Object.assign(newMeasurement.info, measurement.info);
+            newMeasurements[kind]?.entries.push(newMeasurement);
+          }
+        }
+      } catch (error) {
+        // send error to UI ?
+        if (error instanceof Error) {
+          if (logs) {
+            logs.push(
+              createLogEntry({
+                error,
+                parser: 'jcamp converter',
+                relativePath: file.relativePath,
+                message: 'error parsing jdx or dx file',
+              }),
+            );
+          } else {
+            throw error;
+          }
+        }
+      }
+    }
+  }
+
+  return newMeasurements;
+}
+
+function normalizeSpectra(spectra: any) {
+  const data: any[] = [];
+  for (const spectrum of spectra) {
+    let variables = spectrum.variables;
+    if (!variables) {
+      variables = {};
+      variables.x = {
+        label: spectrum.xUnits,
+        symbol: 'X',
+        data: spectrum.data.x || spectrum.data.X,
+      };
+      variables.y = {
+        label: spectrum.yUnits,
+        symbol: 'Y',
+        data: spectrum.data.y || spectrum.data.Y,
+      };
+    } else {
+      for (let key in variables) {
+        const variable = variables[key];
+        if (variable.label) continue;
+        variable.label = variable.name || variable.symbol || key;
+        if (variable.units && !variable.label.includes(variable.units)) {
+          variable.label += ` [${variable.units}]`;
+        }
+      }
+    }
+    data.push({ variables });
+  }
+  return data;
+}

package/src/app-data/loaders/loadMeasurements.ts

@@ -0,0 +1,55 @@
+import type { FileCollection } from 'filelist-utils';
+import { xMinMaxValues } from 'ml-spectra-processing';
+
+import { Measurements, enhance, Enhancers, MeasurementBase } from '../index';
+
+import {
+  MeasurementsLoader,
+  mergeMeasurements,
+} from './utility/measurementLoader';
+import type { ParserLog } from './utility/parserLog';
+
+export interface LoadOptions {
+  loaders?: MeasurementsLoader[];
+  enhancers?: Partial<Enhancers>;
+  logger?: boolean;
+}
+
+export async function loadMeasurements(
+  fileCollection: FileCollection,
+  options: LoadOptions = {},
+) {
+  const measurements: Partial<Measurements> = {};
+  let logs: ParserLog[] = [];
+  const { loaders = [], enhancers = {}, logger = true } = options;
+  for (const loader of loaders) {
+    const loaderData = await loader(fileCollection, logger ? logs : undefined);
+    for (const { entries } of Object.values(loaderData)) {
+      for (const entry of entries) {
+        computeMinMax(entry);
+      }
+    }
+    enhance(loaderData, enhancers);
+    mergeMeasurements(measurements, loaderData);
+  }
+  return { measurements, logs };
+}
+
+function computeMinMax(measurement: MeasurementBase) {
+  for (const datum of measurement.data) {
+    for (const variable of Object.values(datum.variables)) {
+      if (variable.data.length === 0) {
+        // TODO: should we accept empty data?
+        return;
+      }
+      if (
+        typeof variable.min === 'undefined' ||
+        typeof variable.max === 'undefined'
+      ) {
+        const { min, max } = xMinMaxValues(variable.data);
+        variable.min = min;
+        variable.max = max;
+      }
+    }
+  }
+}

package/src/app-data/loaders/proprietary/agilent/cary500Loader.ts

@@ -0,0 +1,91 @@
+import type { FileCollectionItem, FileCollection } from 'filelist-utils';
+
+import {
+  Measurements,
+  MeasurementBase,
+  getMeasurementInfoFromFile,
+  ParserLog,
+  createLogEntry,
+} from '../../../index';
+
+export async function cary500Loader(
+  fileCollection: FileCollection,
+  logs?: ParserLog[],
+): Promise<Partial<Measurements>> {
+  const newMeasurements: Partial<Measurements> = {};
+  const entries: MeasurementBase[] = [];
+
+  for (const file of fileCollection) {
+    if (/\.csv$/i.test(file.name)) {
+      try {
+        const experiments = await convert(file);
+        for (const experiment of experiments) {
+          entries.push(experiment);
+        }
+      } catch (error) {
+        if (error instanceof Error) {
+          if (logs) {
+            logs.push(
+              createLogEntry({
+                kind: 'error',
+                parser: 'cary500Loader',
+                message: 'Error parsing cary500 experiment.',
+                error,
+                relativePath: file.relativePath,
+              }),
+            );
+          } else {
+            throw error;
+          }
+        }
+      }
+    }
+  }
+  newMeasurements.uvvis = { entries };
+  return newMeasurements;
+}
+
+async function convert(file: FileCollectionItem): Promise<MeasurementBase[]> {
+  const text = await file.text();
+  // this format allows many experiments in one file
+  const lines = text.split(/\r?\n/).map((line) => line.trim());
+
+  const titles = lines[0].split(',').map((field) => field.trim());
+  const labelUnits = lines[1].split(',').map((field) => field.trim());
+
+  let lastDataIndex;
+  for (lastDataIndex = 2; lastDataIndex < lines.length; lastDataIndex++) {
+    if (!lines[lastDataIndex].match(/^[\d,.Ee-]+$/)) {
+      break;
+    }
+  }
+  const data = lines.slice(2, lastDataIndex).map((line) => line.split(','));
+  const meta = lines.slice(lastDataIndex);
+  const nbExperiments = Math.floor(labelUnits.length / 2);
+
+  const experiments: MeasurementBase[] = [];
+  for (let i = 0; i < nbExperiments; i++) {
+    const column = i * 2;
+    const xVariable = {
+      ...labelAndUnits(labelUnits[column]),
+      data: data.map((row) => Number(row[column])),
+    };
+    const yVariable = {
+      ...labelAndUnits(labelUnits[column + 1]),
+      data: data.map((row) => Number(row[column + 1])),
+    };
+    experiments.push({
+      ...getMeasurementInfoFromFile(file, titles[column]),
+      meta: JSON.parse(JSON.stringify(meta)),
+      data: [{ variables: { x: xVariable, y: yVariable } }],
+    });
+  }
+  return experiments;
+}
+
+function labelAndUnits(labelUnits: string) {
+  const groups = labelUnits.match(/(?<label>.*) \((?<units>.*)\)/)?.groups;
+  return groups
+    ? { label: groups.label, units: groups.units }
+    : { label: labelUnits, units: '' };
+}

package/src/app-data/loaders/spcLoader.ts

@@ -0,0 +1,55 @@
+import type { FileCollection } from 'filelist-utils';
+import { parse, guessSpectraType } from 'spc-parser';
+
+import { assert } from '../../components/index';
+import type { MeasurementKind, Measurements, MeasurementBase } from '../index';
+
+import { getMeasurementInfoFromFile } from './utility/getMeasurementInfoFromFile';
+import { ParserLog, createLogEntry } from './utility/parserLog';
+
+/**
+ *
+ * @param fileCollection - the dragged file/files
+ * @param logger - whether to log to console or not
+ * @returns - new measurements object to be merged
+ */
+export async function spcLoader(
+  fileCollection: FileCollection,
+  logs?: ParserLog[],
+): Promise<Partial<Measurements>> {
+  const measurements: Partial<Measurements> = {};
+  for (const file of fileCollection) {
+    if (/\.spc$/i.test(file.name)) {
+      try {
+        const parsed = parse(await file.arrayBuffer());
+        const spectraType: MeasurementKind = guessSpectraType(parsed.meta);
+        if (!measurements[spectraType]) {
+          measurements[spectraType] = { entries: [] };
+        }
+        assert(
+          measurements[spectraType],
+          'Error while loading, kind is not defined',
+        );
+        measurements[spectraType]?.entries.push({
+          meta: parsed.meta,
+          ...getMeasurementInfoFromFile(file, parsed.meta.memo),
+          data: parsed.spectra as unknown as MeasurementBase['data'],
+        });
+      } catch (error) {
+        if (error instanceof Error && logs) {
+          logs.push(
+            createLogEntry({
+              parser: 'spc-parser',
+              relativePath: file.relativePath,
+              error,
+            }),
+          );
+        } else {
+          throw error;
+        }
+      }
+    }
+  }
+
+  return measurements;
+}

package/src/app-data/loaders/utility/getMeasurementInfoFromFile.ts

@@ -0,0 +1,20 @@
+import { v4 } from '@lukeed/uuid';
+import type { FileCollectionItem } from 'filelist-utils';
+
+/**
+ * creates a template for the MeasurementBase (part)
+ * generated from just the file metadata only and id
+ * @param obj - file as collection item.
+ */
+export function getMeasurementInfoFromFile(
+  { name, relativePath, lastModified, size }: FileCollectionItem,
+  title: string,
+) {
+  return {
+    id: v4(),
+    info: {
+      title,
+      file: { name, path: relativePath, lastModified, size },
+    },
+  };
+}