react-science 0.19.1

package/lib/app-data/loaders/cdfLoader.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cdfLoader = void 0;
+// @ts-expect-error netcdfjs has no types at the moment.
+const netcdfjs_1 = require("netcdfjs");
+const index_1 = require("../../components/index");
+const getMeasurementInfoFromFile_1 = require("./utility/getMeasurementInfoFromFile");
+const parserLog_1 = require("./utility/parserLog");
+async function cdfLoader(fileCollection, logs) {
+    const newMeasurements = {};
+    let kind;
+    for (const file of fileCollection) {
+        if (/\.cdf$/i.test(file.name)) {
+            try {
+                const reader = new netcdfjs_1.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: [] };
+                }
+                (0, index_1.assert)(newMeasurements[kind], 'Error while loading, kind is not defined');
+                const newMeasurement = {
+                    ...(0, getMeasurementInfoFromFile_1.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((0, parserLog_1.createLogEntry)({
+                            error,
+                            parser: 'cdfLoader',
+                            message: 'error parsing file from cdfLoader',
+                            relativePath: file.relativePath,
+                        }));
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+            }
+        }
+    }
+    return newMeasurements;
+}
+exports.cdfLoader = cdfLoader;
+function chromatogramWithMassSpectra(reader) {
+    // 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 = [];
+    const allIntensities = [];
+    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 = [];
+    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) {
+    // Taken from: https://github.com/cheminfo/netcdf-gcms
+    let data = [];
+    const intensities = reader.getDataVariable('ordinate_values');
+    const numberPoints = intensities.length;
+    const detector = reader.getAttribute('detector_name');
+    let channel;
+    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 = reader.getDataVariable('actual_delay_time')[0];
+    const runtimeLength = 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 = [];
+    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, globalAttributes) {
+    reader.header.meta = {};
+    for (const item of globalAttributes) {
+        reader.header.meta[item.name] = item.value;
+    }
+}

package/lib/app-data/loaders/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./proprietary/agilent/cary500Loader"), exports);
+__exportStar(require("./utility/index"), exports);
+__exportStar(require("./biologicLoader"), exports);
+__exportStar(require("./cdfLoader"), exports);
+__exportStar(require("./jcampLoader"), exports);
+__exportStar(require("./loadMeasurements"), exports);
+__exportStar(require("./spcLoader"), exports);
+__exportStar(require("./wdfLoader"), exports);

package/lib/app-data/loaders/jcampLoader.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jcampLoader = void 0;
+const jcampconverter_1 = require("jcampconverter");
+const index_1 = require("../../components/index");
+const getMeasurementInfoFromFile_1 = require("./utility/getMeasurementInfoFromFile");
+const parserLog_1 = require("./utility/parserLog");
+/**
+ *
+ * @param fileCollection - the dragged file/files
+ * @param logger - whether to log to console or not
+ * @returns - new measurements object to be merged
+ */
+async function jcampLoader(fileCollection, logs) {
+    const newMeasurements = {};
+    for (const file of fileCollection) {
+        if (/(?:\.jdx|\.dx)$/i.test(file.name)) {
+            try {
+                const parsed = (0, jcampconverter_1.convert)(await file.text(), { keepRecordsRegExp: /.*/ });
+                for (const measurement of parsed.flatten) {
+                    let kind;
+                    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: [] };
+                        }
+                        (0, index_1.assert)(newMeasurements[kind], 'Error while loading, kind is not defined');
+                        const newMeasurement = {
+                            ...(0, getMeasurementInfoFromFile_1.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((0, parserLog_1.createLogEntry)({
+                            error,
+                            parser: 'jcamp converter',
+                            relativePath: file.relativePath,
+                            message: 'error parsing jdx or dx file',
+                        }));
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+            }
+        }
+    }
+    return newMeasurements;
+}
+exports.jcampLoader = jcampLoader;
+function normalizeSpectra(spectra) {
+    const data = [];
+    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/lib/app-data/loaders/loadMeasurements.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadMeasurements = void 0;
+const ml_spectra_processing_1 = require("ml-spectra-processing");
+const index_1 = require("../index");
+const measurementLoader_1 = require("./utility/measurementLoader");
+async function loadMeasurements(fileCollection, options = {}) {
+    const measurements = {};
+    let logs = [];
+    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);
+            }
+        }
+        (0, index_1.enhance)(loaderData, enhancers);
+        (0, measurementLoader_1.mergeMeasurements)(measurements, loaderData);
+    }
+    return { measurements, logs };
+}
+exports.loadMeasurements = loadMeasurements;
+function computeMinMax(measurement) {
+    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 } = (0, ml_spectra_processing_1.xMinMaxValues)(variable.data);
+                variable.min = min;
+                variable.max = max;
+            }
+        }
+    }
+}

package/lib/app-data/loaders/proprietary/agilent/cary500Loader.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cary500Loader = void 0;
+const index_1 = require("../../../index");
+async function cary500Loader(fileCollection, logs) {
+    const newMeasurements = {};
+    const entries = [];
+    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((0, index_1.createLogEntry)({
+                            kind: 'error',
+                            parser: 'cary500Loader',
+                            message: 'Error parsing cary500 experiment.',
+                            error,
+                            relativePath: file.relativePath,
+                        }));
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+            }
+        }
+    }
+    newMeasurements.uvvis = { entries };
+    return newMeasurements;
+}
+exports.cary500Loader = cary500Loader;
+async function convert(file) {
+    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 = [];
+    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({
+            ...(0, index_1.getMeasurementInfoFromFile)(file, titles[column]),
+            meta: JSON.parse(JSON.stringify(meta)),
+            data: [{ variables: { x: xVariable, y: yVariable } }],
+        });
+    }
+    return experiments;
+}
+function labelAndUnits(labelUnits) {
+    const groups = labelUnits.match(/(?<label>.*) \((?<units>.*)\)/)?.groups;
+    return groups
+        ? { label: groups.label, units: groups.units }
+        : { label: labelUnits, units: '' };
+}

package/lib/app-data/loaders/spcLoader.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spcLoader = void 0;
+const spc_parser_1 = require("spc-parser");
+const index_1 = require("../../components/index");
+const getMeasurementInfoFromFile_1 = require("./utility/getMeasurementInfoFromFile");
+const parserLog_1 = require("./utility/parserLog");
+/**
+ *
+ * @param fileCollection - the dragged file/files
+ * @param logger - whether to log to console or not
+ * @returns - new measurements object to be merged
+ */
+async function spcLoader(fileCollection, logs) {
+    const measurements = {};
+    for (const file of fileCollection) {
+        if (/\.spc$/i.test(file.name)) {
+            try {
+                const parsed = (0, spc_parser_1.parse)(await file.arrayBuffer());
+                const spectraType = (0, spc_parser_1.guessSpectraType)(parsed.meta);
+                if (!measurements[spectraType]) {
+                    measurements[spectraType] = { entries: [] };
+                }
+                (0, index_1.assert)(measurements[spectraType], 'Error while loading, kind is not defined');
+                measurements[spectraType]?.entries.push({
+                    meta: parsed.meta,
+                    ...(0, getMeasurementInfoFromFile_1.getMeasurementInfoFromFile)(file, parsed.meta.memo),
+                    data: parsed.spectra,
+                });
+            }
+            catch (error) {
+                if (error instanceof Error && logs) {
+                    logs.push((0, parserLog_1.createLogEntry)({
+                        parser: 'spc-parser',
+                        relativePath: file.relativePath,
+                        error,
+                    }));
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+    }
+    return measurements;
+}
+exports.spcLoader = spcLoader;

package/lib/app-data/loaders/utility/getMeasurementInfoFromFile.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMeasurementInfoFromFile = void 0;
+const uuid_1 = require("@lukeed/uuid");
+/**
+ * creates a template for the MeasurementBase (part)
+ * generated from just the file metadata only and id
+ * @param obj - file as collection item.
+ */
+function getMeasurementInfoFromFile({ name, relativePath, lastModified, size }, title) {
+    return {
+        id: (0, uuid_1.v4)(),
+        info: {
+            title,
+            file: { name, path: relativePath, lastModified, size },
+        },
+    };
+}
+exports.getMeasurementInfoFromFile = getMeasurementInfoFromFile;

package/lib/app-data/loaders/utility/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./getMeasurementInfoFromFile"), exports);
+__exportStar(require("./measurementLoader"), exports);
+__exportStar(require("./parserLog"), exports);

package/lib/app-data/loaders/utility/measurementLoader.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeMeasurements = void 0;
+const index_1 = require("../../../components/index");
+function mergeMeasurements(measurements, newMeasurements) {
+    //fixes for putting type "string" to key
+    let kind;
+    for (kind in newMeasurements) {
+        if (!measurements[kind]) {
+            measurements[kind] = { entries: [] };
+        }
+        (0, index_1.assert)(measurements[kind], 'Error while loading, kind is not defined');
+        const entries = newMeasurements[kind]?.entries || [];
+        measurements[kind]?.entries.push(...entries);
+    }
+}
+exports.mergeMeasurements = mergeMeasurements;

package/lib/app-data/loaders/utility/parserLog.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogEntry = void 0;
+function createLogEntry(info) {
+    const { parser = 'biologic-converter', branch, kind = 'error', message = 'Error parsing biologic experiment.', error, relativePath, } = info;
+    const log = {
+        parser,
+        kind,
+        message,
+    };
+    if (error) {
+        log.error = error;
+    }
+    if (relativePath) {
+        log.relativePath = relativePath;
+    }
+    if (branch) {
+        log.branch = branch;
+    }
+    return log;
+}
+exports.createLogEntry = createLogEntry;

package/lib/app-data/loaders/wdfLoader.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wdfLoader = void 0;
+const wdf_parser_1 = require("wdf-parser");
+const getMeasurementInfoFromFile_1 = require("./utility/getMeasurementInfoFromFile");
+const parserLog_1 = require("./utility/parserLog");
+/**
+ *
+ * @param fileCollection - the dragged file/files
+ * @param logger - whether to log to console or not
+ * @returns - new measurements object to be merged
+ */
+async function wdfLoader(fileCollection, logs) {
+    const measurements = {};
+    const entries = [];
+    for (const file of fileCollection) {
+        if (/\.wdf$/i.test(file.name)) {
+            try {
+                const parsed = (0, wdf_parser_1.parse)(await file.arrayBuffer());
+                entries.push({
+                    meta: parsed.fileHeader,
+                    ...(0, getMeasurementInfoFromFile_1.getMeasurementInfoFromFile)(file, parsed.fileHeader.title),
+                    data: normalizeSpectra(parsed.blocks),
+                });
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    if (logs) {
+                        logs.push((0, parserLog_1.createLogEntry)({
+                            parser: 'wdf',
+                            error,
+                            message: 'error reading wdf file',
+                            relativePath: file.relativePath,
+                        }));
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+            }
+        }
+    }
+    measurements.raman = { entries };
+    return measurements;
+}
+exports.wdfLoader = wdfLoader;
+function normalizeSpectra(blocks) {
+    const yVariables = getYVariables(blocks);
+    const origins = getOrigins(blocks);
+    const results = [];
+    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) {
+    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 = {
+        label: groups?.label || 'Arbitrary Units',
+        units: groups?.units || '',
+        data: Array.from(xList.values),
+    };
+    return xVariable;
+}
+function getYVariables(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 = [];
+    for (const spectrum of dataBlock.spectra) {
+        yVariables.push({
+            data: Array.from(spectrum),
+            units: '',
+            label: 'Arbitrary Intensity',
+        });
+    }
+    return yVariables;
+}
+function getOrigins(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 = [];
+    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;
+}