react-science 0.19.1

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

@@ -0,0 +1,3 @@
+export * from './getMeasurementInfoFromFile';
+export * from './measurementLoader';
+export * from './parserLog';

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

@@ -0,0 +1,27 @@
+import type { FileCollection } from 'filelist-utils';
+
+import { assert } from '../../../components/index';
+import type { MeasurementBase, Measurements } from '../../index';
+
+import type { ParserLog } from './parserLog';
+
+export type MeasurementsLoader = (
+  fileCollection: FileCollection,
+  logs?: ParserLog[],
+) => Promise<Partial<Measurements>>;
+
+export function mergeMeasurements(
+  measurements: Partial<Measurements>,
+  newMeasurements: Partial<Measurements>,
+) {
+  //fixes for putting type "string" to key
+  let kind: keyof typeof newMeasurements;
+  for (kind in newMeasurements) {
+    if (!measurements[kind]) {
+      measurements[kind] = { entries: [] };
+    }
+    assert(measurements[kind], 'Error while loading, kind is not defined');
+    const entries: MeasurementBase[] = newMeasurements[kind]?.entries || [];
+    measurements[kind]?.entries.push(...entries);
+  }
+}

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

@@ -0,0 +1,39 @@
+export interface ParserLog {
+  kind: 'error' | 'warn' | 'info' | 'debug' | 'summary';
+  /* name of the parser or converter*/
+  parser: string;
+  message: string;
+  /* if the parser has branches for text, binary, etc. */
+  branch?: string;
+  /* from FileCollectionItem or other*/
+  relativePath?: string;
+  error?: Error;
+}
+
+export function createLogEntry(info: Partial<ParserLog>): ParserLog {
+  const {
+    parser = 'biologic-converter',
+    branch,
+    kind = 'error',
+    message = 'Error parsing biologic experiment.',
+    error,
+    relativePath,
+  } = info;
+
+  const log: ParserLog = {
+    parser,
+    kind,
+    message,
+  };
+
+  if (error) {
+    log.error = error;
+  }
+  if (relativePath) {
+    log.relativePath = relativePath;
+  }
+  if (branch) {
+    log.branch = branch;
+  }
+  return log;
+}

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

@@ -0,0 +1,144 @@
+import { MeasurementVariable } from 'cheminfo-types';
+import type { FileCollection } from 'filelist-utils';
+import { parse, Wdf } from 'wdf-parser';
+
+import type { 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 wdfLoader(
+  fileCollection: FileCollection,
+  logs?: ParserLog[],
+): Promise<Partial<Measurements>> {
+  const measurements: Partial<Measurements> = {};
+  const entries: MeasurementBase[] = [];
+
+  for (const file of fileCollection) {
+    if (/\.wdf$/i.test(file.name)) {
+      try {
+        const parsed = parse(await file.arrayBuffer());
+        entries.push({
+          meta: parsed.fileHeader,
+          ...getMeasurementInfoFromFile(file, parsed.fileHeader.title),
+          data: normalizeSpectra(parsed.blocks),
+        });
+      } catch (error) {
+        if (error instanceof Error) {
+          if (logs) {
+            logs.push(
+              createLogEntry({
+                parser: 'wdf',
+                error,
+                message: 'error reading wdf file',
+                relativePath: file.relativePath,
+              }),
+            );
+          } else {
+            throw error;
+          }
+        }
+      }
+    }
+  }
+
+  measurements.raman = { entries };
+  return measurements;
+}
+
+function normalizeSpectra(blocks: Wdf['blocks']) {
+  const yVariables = getYVariables(blocks);
+  const origins = getOrigins(blocks);
+
+  const results: MeasurementBase['data'] = [];
+
+  for (let i = 0; i < yVariables.length; i++) {
+    const yVariable = yVariables[i];
+    let origin = origins[i] || {};
+
+    results.push({
+      variables: { x: getXVariable(blocks), y: yVariable },
+      meta: { ...origin },
+    });
+  }
+  return results;
+}
+
+function getXVariable(blocks: Wdf['blocks']) {
+  const xBlock = blocks.find(
+    (block) => block.blockType === 'WDF_BLOCKID_XLIST',
+  );
+
+  const xList = xBlock?.xList;
+  const groups = xList?.units.match(/(?<label>.*) \((?<units>.*)\)/)?.groups;
+
+  if (!xList) {
+    throw new Error('no xList data found in wdf file');
+  }
+
+  const xVariable: MeasurementVariable = {
+    label: groups?.label || 'Arbitrary Units',
+    units: groups?.units || '',
+    data: Array.from(xList.values),
+  };
+  return xVariable;
+}
+
+function getYVariables(blocks: Wdf['blocks']) {
+  const dataBlock = blocks.find(
+    (block) => block.blockType === 'WDF_BLOCKID_DATA',
+  );
+
+  if (!dataBlock?.spectra) {
+    throw new Error('no spectrum found in data block of wdf file');
+  }
+
+  const yVariables: MeasurementVariable[] = [];
+  for (const spectrum of dataBlock.spectra) {
+    yVariables.push({
+      data: Array.from(spectrum),
+      units: '',
+      label: 'Arbitrary Intensity',
+    });
+  }
+
+  return yVariables;
+}
+
+type Origin = {
+  xPositionUnits: string;
+  yPositionUnits: string;
+  xPosition: number | bigint;
+  yPosition: number | bigint;
+};
+function getOrigins(blocks: Wdf['blocks']) {
+  const originBlock = blocks.find(
+    (block) => block.blockType === 'WDF_BLOCKID_ORIGIN',
+  );
+  if (!originBlock) return [];
+
+  const xPositions = originBlock.origins?.find((entry) => entry.label === 'X');
+  const yPositions = originBlock.origins?.find((entry) => entry.label === 'Y');
+  const xOrigins = xPositions?.axisOrigins;
+  const yOrigins = yPositions?.axisOrigins;
+
+  const origins: Origin[] = [];
+  if (xOrigins && yOrigins) {
+    for (let i = 0; i < xOrigins.length; i++) {
+      // we should add some xIndex and yIndex based on https://github.com/cheminfo/raman-spectrum/blob/1d3bc62ebe2930f8c35fcf65689b090f5b22ba9e/src/utils/surfaceAnalysis.js#L15-L70
+      origins.push({
+        xPositionUnits: xPositions.unit,
+        yPositionUnits: yPositions.unit,
+        xPosition: xOrigins[i],
+        yPosition: yOrigins[i],
+      });
+    }
+  }
+  return origins;
+}

package/src/app-data/state/appState.tsx

@@ -0,0 +1,88 @@
+import produce from 'immer';
+import {
+  createContext,
+  Dispatch,
+  ReactNode,
+  useContext,
+  useReducer,
+} from 'react';
+
+import { AppStateAction } from './appStateActions';
+import { AppData, getEmptyAppData } from './data/index';
+import { appStateProducer } from './producers/index';
+import { AppSettings } from './settings/AppSettings';
+import { getEmptyAppSettings } from './settings/getEmptyAppSettings';
+import { getEmptyAppView, AppView } from './view/index';
+
+export interface AppState {
+  load: AppLoad;
+  data: AppData;
+  view: AppView;
+  settings: AppSettings;
+}
+
+export interface AppLoad {
+  isLoading: boolean;
+}
+
+function getEmptyAppState(): AppState {
+  return {
+    load: {
+      isLoading: false,
+    },
+    data: getEmptyAppData(),
+    view: getEmptyAppView(),
+    settings: getEmptyAppSettings(),
+  };
+}
+
+const appStateContext = createContext<AppState | null>(null);
+
+export function useAppState(): AppState {
+  const appState = useContext(appStateContext);
+  if (!appState) {
+    throw new Error('useAppState must be used within an AppStateProvider');
+  }
+  return appState;
+}
+
+export type AppDispatch = Dispatch<AppStateAction>;
+
+const appDispatchContext = createContext<AppDispatch | null>(null);
+
+export function useAppDispatch(): AppDispatch {
+  const appDispatch = useContext(appDispatchContext);
+  if (!appDispatch) {
+    throw new Error('useAppDispatch must be used within an AppStateProvider');
+  }
+  return appDispatch;
+}
+
+export function useAppData(): AppData {
+  return useAppState().data;
+}
+
+export function useAppView(): AppView {
+  return useAppState().view;
+}
+
+export function useAppSettings(): AppSettings {
+  return useAppState().settings;
+}
+
+const appReducer = produce(appStateProducer);
+
+export function AppStateProvider(props: { children: ReactNode }) {
+  const [appState, appDispatch] = useReducer(
+    appReducer,
+    null,
+    getEmptyAppState,
+  );
+  return (
+    <appDispatchContext.Provider value={appDispatch}>
+      <appStateContext.Provider value={appState}>
+        {props.children}
+      </appStateContext.Provider>
+    </appDispatchContext.Provider>
+  );
+}

package/src/app-data/state/appStateActions.ts

@@ -0,0 +1,49 @@
+import { AppState } from './appState';
+import {
+  MeasurementKind,
+  MeasurementKindAndId,
+  Measurements,
+} from './data/index';
+import { MeasurementAppView, Plot2DZoom } from './view/index';
+
+type ActionType<Action, Payload = void> = Payload extends void
+  ? { type: Action }
+  : { type: Action; payload: Payload };
+
+export type AppStateAction =
+  | ActionType<'LOAD_START'>
+  | ActionType<'LOAD_STOP'>
+  | ActionType<'ADD_MEASUREMENTS', Partial<Measurements>>
+  | ActionType<'LOAD_FULL_STATE', AppState>
+  | ActionType<'PLOT_ZOOM', { kind: MeasurementKind; zoom: Plot2DZoom }>
+  | ActionType<'PLOT_ZOOM_OUT', { kind: MeasurementKind }>
+  | ActionType<
+      'SELECT_MEASUREMENT',
+      MeasurementKindAndId & { acc: 'add' | 'remove' | 'replace' }
+    >
+  | ActionType<
+      'SELECT_ALL_MEASUREMENTS',
+      { select: boolean; kind: MeasurementKind }
+    >
+  | ActionType<'SELECT_MEASUREMENT_KIND', MeasurementKind>
+  | ActionType<'SET_MEASUREMENT_VISIBILITY', { id: string; isVisible: boolean }>
+  | ActionType<
+      'SET_SELECTED_MEASUREMENTS_VISIBILITY',
+      { kind: MeasurementKind; isVisible: boolean }
+    >
+  | ActionType<
+      'CHANGE_MEASUREMENTS_DISPLAY',
+      { display: Partial<MeasurementAppView> }
+    >
+  | ActionType<
+      'CHANGE_MEASUREMENT_DISPLAY',
+      {
+        measurement: MeasurementKindAndId;
+        display: Partial<MeasurementAppView>;
+      }
+    >
+  | ActionType<'REMOVE_SELECTED_MEASUREMENTS', { kind: MeasurementKind }>
+  | ActionType<
+      'IV_PLOT_SELECT_VARIABLE',
+      { axis: 'x' | 'y'; variable: string }
+    >;

package/src/app-data/state/data/AppData.ts

@@ -0,0 +1,77 @@
+import type { Instrument, MeasurementVariable } from 'cheminfo-types';
+
+import type { IrMeasurement, IvMeasurement } from '../../index';
+
+export interface AppData {
+  measurements: Measurements;
+}
+
+/**
+ * When we have a simple measurement like uv, ir, etc, data should only contain one element
+ * Sometimes measurements are more complex like in GC / MS, GC / MS / MS, raman images, etc. In this case we will add the meta and info properties
+ * to differentiate each measurement
+ * If we have isotherm with gaz absorption / desorption this format should also be used.
+ * The 'info'for each 'Measurement' should be normalized.
+ */
+
+type UUID = string;
+
+export interface MeasurementBase {
+  id: UUID;
+  info: MeasurementBaseInfo;
+  // Unstructured object
+  meta: Record<string, any>;
+  data: Array<{
+    info?: Record<string, any>;
+    meta?: Record<string, any>;
+    variables: Record<string, MeasurementVariable>;
+  }>;
+}
+
+export interface MeasurementBaseInfo {
+  title: string;
+  file?: MeasurementFile;
+  instrument?: Instrument;
+}
+
+export interface MeasurementFile {
+  name: string;
+  path?: string;
+  size?: number;
+  lastModified?: number;
+}
+
+export interface Measurements {
+  ir: {
+    entries: IrMeasurement[];
+  };
+  iv: {
+    entries: IvMeasurement[];
+  };
+  raman: {
+    entries: MeasurementBase[];
+  };
+  uv: {
+    entries: MeasurementBase[];
+  };
+  uvvis: {
+    entries: MeasurementBase[];
+  };
+  gclc: {
+    entries: MeasurementBase[];
+  };
+  gclcms: {
+    entries: MeasurementBase[];
+  };
+  nmr: {
+    entries: MeasurementBase[];
+  };
+  mass: {
+    entries: MeasurementBase[];
+  };
+  other: {
+    entries: MeasurementBase[];
+  };
+}
+
+export type MeasurementKind = keyof Measurements;

package/src/app-data/state/data/data.helpers.ts

@@ -0,0 +1,159 @@
+import { assertNotNull } from '../../../components/index';
+import type { AppState, AppView } from '../index';
+
+import type { AppData, MeasurementKind, Measurements } from './AppData';
+import { measurementKinds } from './kinds';
+
+export function getMeasurement(
+  measurements: Measurements,
+  kind: MeasurementKind,
+  selected: string,
+) {
+  const measurement = measurements[kind].entries.find(
+    (entry) => entry.id === selected,
+  );
+  return measurement || null;
+}
+
+export function getMeasurementOrFail(
+  measurements: Measurements,
+  kind: MeasurementKind,
+  selected: string,
+) {
+  const result = getMeasurement(measurements, kind, selected);
+  assertNotNull(result);
+  return result;
+}
+
+export function getFirstMeasurement<Kind extends MeasurementKind>(
+  measurements: Measurements,
+  kind: Kind,
+): { kind: Kind; measurement: Measurements[Kind]['entries'][0] } | null {
+  const measurement = measurements[kind].entries[0];
+  if (measurement) return { kind, measurement };
+
+  return null;
+}
+export function getFirstMeasurementOrFail<Kind extends MeasurementKind>(
+  measurements: Measurements,
+  kind: Kind,
+) {
+  const result = getFirstMeasurement(measurements, kind);
+  assertNotNull(result);
+  return result;
+}
+
+export function getCurrentMeasurement(state: AppState) {
+  const selectedMeasurement = getSelectedMeasurement(state.view);
+  if (!selectedMeasurement) return null;
+
+  return getMeasurement(
+    state.data.measurements,
+    selectedMeasurement.kind,
+    selectedMeasurement.id,
+  );
+}
+
+export function getCurrentMeasurementData(state: AppState) {
+  const selectedMeasurement = getCurrentMeasurement(state);
+  if (!selectedMeasurement) return null;
+  const kindAndId = getMeasurementKindAndId(state.data, selectedMeasurement.id);
+  const display = state.view.measurements[selectedMeasurement.id];
+  return { data: selectedMeasurement, display, kindAndId };
+}
+
+export function getFirstSelectedMeasurementData(state: AppState) {
+  const {
+    data,
+    view: {
+      selectedMeasurements,
+      selectedKind,
+      measurements: measurementsView,
+    },
+  } = state;
+  if (!selectedKind) return null;
+
+  const measurements = selectedMeasurements[selectedKind];
+  if (!measurements?.length) return null;
+  assertNotNull(measurements);
+
+  const measurementId = measurements[0];
+  const measurement = getMeasurement(
+    data.measurements,
+    selectedKind,
+    measurementId,
+  );
+
+  return { data: measurement, display: measurementsView[measurementId] };
+}
+
+export interface MeasurementKindAndId {
+  kind: MeasurementKind;
+  id: string;
+}
+
+export function getMeasurementKindAndId(data: AppData, measurementId: string) {
+  for (let kind of measurementKinds) {
+    const measurement = getMeasurement(data.measurements, kind, measurementId);
+    if (measurement) return { kind, id: measurementId };
+  }
+  throw new Error(`Measurement kind for ${measurementId} not found`);
+}
+
+export function getSelectedMeasurement(
+  view: AppView,
+): MeasurementKindAndId | null {
+  const { selectedKind, selectedMeasurements } = view;
+  if (!selectedKind) return null;
+  const kind = selectedKind;
+  const currentMeasurements = selectedMeasurements[kind];
+  if (!currentMeasurements || currentMeasurements.length !== 1) return null;
+  const id = currentMeasurements[0];
+  return { kind, id };
+}
+
+export function getSelectedMeasurementOrFail(view: AppView) {
+  const selected = getSelectedMeasurement(view);
+  assertNotNull(selected);
+  return selected;
+}
+
+export function* iterateMeasurementEntries(
+  measurements: Partial<Measurements>,
+) {
+  for (const [measurementKind, measurementData] of Object.entries(
+    measurements,
+  )) {
+    for (let measurement of measurementData.entries) {
+      yield { kind: measurementKind as MeasurementKind, measurement };
+    }
+  }
+}
+
+export type MeasurementAndView<Kind extends MeasurementKind> = {
+  measurement: Measurements[Kind]['entries'][number];
+  view: AppView['measurements'][string];
+};
+
+export function* iterateKindMeasurementsAndView<Kind extends MeasurementKind>(
+  state: AppState,
+  kind: Kind,
+): IterableIterator<MeasurementAndView<Kind>> {
+  const measurements = state.data.measurements[kind];
+  const view = state.view.measurements;
+  for (let measurement of measurements.entries) {
+    yield { measurement, view: view[measurement.id] };
+  }
+}
+
+export function getExistingMeasurementKinds(
+  measurements: Partial<Measurements>,
+): MeasurementKind[] {
+  const result: MeasurementKind[] = [];
+  for (const [kind, { entries }] of Object.entries(measurements)) {
+    if (entries.length > 0) {
+      result.push(kind as MeasurementKind);
+    }
+  }
+  return result;
+}

package/src/app-data/state/data/getEmptyAppData.ts

@@ -0,0 +1,18 @@
+import type { AppData } from './AppData';
+
+export function getEmptyAppData(): AppData {
+  return {
+    measurements: {
+      ir: { entries: [] },
+      iv: { entries: [] },
+      raman: { entries: [] },
+      uv: { entries: [] },
+      uvvis: { entries: [] },
+      gclc: { entries: [] },
+      gclcms: { entries: [] },
+      nmr: { entries: [] },
+      mass: { entries: [] },
+      other: { entries: [] },
+    },
+  };
+}

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

@@ -0,0 +1,4 @@
+export * from './data.helpers';
+export * from './AppData';
+export * from './getEmptyAppData';
+export * from './kinds';

package/src/app-data/state/data/kinds.ts

@@ -0,0 +1,16 @@
+import type { MeasurementKind } from './AppData';
+
+export const kindLabels: Record<MeasurementKind, string> = {
+  ir: 'IR',
+  iv: 'IV',
+  raman: 'Raman',
+  uv: 'UV',
+  uvvis: 'UV-VIS',
+  mass: 'Mass',
+  gclc: 'GC/LC',
+  gclcms: 'GC/LC MS',
+  nmr: 'NMR',
+  other: 'Other',
+};
+
+export const measurementKinds = Object.keys(kindLabels) as MeasurementKind[];

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

@@ -0,0 +1,4 @@
+export * from './appState';
+export * from './data/index';
+export * from './settings/index';
+export * from './view/index';