+ `;
+const InitTip = () => {
+ d3.select('.peak-tp').remove();
+ const tip = (0, _d3Tip.default)().attr('class', 'd3-tip').html(_ref => {
+ let {
+ d,
+ layout
+ } = _ref;
+ return tpDiv(d, _format.default.spectraDigit(layout));
+ });
+ return tip;
+};
+exports.InitTip = InitTip;
\ No newline at end of file
diff --git a/dist/helpers/integration.js b/dist/helpers/integration.js
new file mode 100644
index 00000000..b1d59025
--- /dev/null
+++ b/dist/helpers/integration.js
@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.getArea = exports.getAbsoluteArea = exports.calcArea = void 0;
+var _calc = require("./calc");
+/* eslint-disable no-mixed-operators */
+
+const getArea = (xL, xU, data) => {
+ let [iL, iU] = [data.length - 1, 0];
+ for (let i = 0; i < data.length; i += 1) {
+ const pt = data[i];
+ if (xL <= pt.x && pt.x <= xU) {
+ if (iL > i) {
+ iL = i;
+ }
+ if (i > iU) {
+ iU = i;
+ }
+ }
+ }
+ return Math.abs(data[iU].k - data[iL].k);
+};
+exports.getArea = getArea;
+const getAbsoluteArea = (xL, xU, data) => {
+ const ps = data.filter(d => d.x > xL && d.x < xU);
+ if (!ps[0]) return 0;
+ let area = 0;
+ const point1 = ps[0];
+ const point2 = ps[ps.length - 1];
+ const slope = (0, _calc.calcSlope)(point1.x, point1.y, point2.x, point2.y);
+ let lastDY = point1.y;
+ if (ps.length > 1) {
+ for (let i = 1; i < ps.length; i += 1) {
+ const pt = ps[i];
+ const lastD = ps[i - 1];
+ const y = slope * (pt.x - lastD.x) + lastDY;
+ lastDY = y;
+ const delta = Math.abs(pt.y - y);
+ area += delta;
+ }
+ }
+ return area;
+};
+exports.getAbsoluteArea = getAbsoluteArea;
+const calcArea = exports.calcArea = function calcArea(d, refArea, refFactor) {
+ let ignoreRef = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+ if (ignoreRef) {
+ const {
+ absoluteArea
+ } = d;
+ return !absoluteArea ? 0 : d.absoluteArea.toFixed(2);
+ }
+ return (d.area * refFactor / refArea).toFixed(2);
+};
+
+// eslint-disable-line
\ No newline at end of file
diff --git a/dist/helpers/mount.js b/dist/helpers/mount.js
new file mode 100644
index 00000000..4f595914
--- /dev/null
+++ b/dist/helpers/mount.js
@@ -0,0 +1,110 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.MountThresLine = exports.MountTags = exports.MountRef = exports.MountPath = exports.MountMarker = exports.MountMainFrame = exports.MountGrid = exports.MountComparePath = exports.MountClip = exports.MountBars = exports.MountAxisLabelY = exports.MountAxisLabelX = exports.MountAxis = void 0;
+var _compass = require("./compass");
+const MountTags = target => {
+ const igbPath = target.root.append('g').attr('class', 'igbPath-clip').attr('clip-path', 'url(#clip)');
+ const igcPath = target.root.append('g').attr('class', 'igcPath-clip').attr('clip-path', 'url(#clip)');
+ const igtPath = target.root.append('g').attr('class', 'igtPath-clip').attr('clip-path', 'url(#clip)');
+ const pPath = target.root.append('g').attr('class', 'pPath-clip').attr('clip-path', 'url(#clip)');
+ const bpPath = target.root.append('g').attr('class', 'bpPath-clip').attr('clip-path', 'url(#clip)');
+ const bpTxt = target.root.append('g').attr('class', 'bpTxt-clip').attr('clip-path', 'url(#clip)');
+ const mpybPath = target.root.append('g').attr('class', 'mpybPath-clip').attr('clip-path', 'url(#clip)');
+ const mpyt1Path = target.root.append('g').attr('class', 'mpyt1Path-clip').attr('clip-path', 'url(#clip)');
+ const mpyt2Path = target.root.append('g').attr('class', 'mpyt2Path-clip').attr('clip-path', 'url(#clip)');
+ const mpypPath = target.root.append('g').attr('class', 'mpypPath-clip').attr('clip-path', 'url(#clip)');
+ const aucPath = target.root.append('g').attr('class', 'aucPath-clip').attr('clip-path', 'url(#clip)');
+ const peckerPath = target.root.append('g').attr('class', 'peckerPath-clip').attr('clip-path', 'url(#clip)');
+ return {
+ pPath,
+ bpPath,
+ bpTxt,
+ igbPath,
+ igcPath,
+ igtPath,
+ mpybPath,
+ mpyt1Path,
+ mpyt2Path,
+ mpypPath,
+ aucPath,
+ peckerPath // eslint-disable-line
+ };
+};
+exports.MountTags = MountTags;
+const MountBars = target => {
+ const bars = target.root.append('g').attr('class', 'bars-clip').attr('clip-path', 'url(#clip)');
+ return bars;
+};
+exports.MountBars = MountBars;
+const MountRef = target => {
+ const ref = target.root.append('g').attr('class', 'ref-clip').attr('clip-path', 'url(#ref-clip)');
+ return ref;
+};
+exports.MountRef = MountRef;
+const MountPath = (target, color) => {
+ const path = target.root.append('g').attr('class', 'line-clip').attr('clip-path', 'url(#clip)').append('path').attr('class', 'line').style('fill', 'none').style('stroke', color).style('stroke-width', 1).on('click', event => (0, _compass.ClickCompass)(event, target));
+ return path;
+};
+exports.MountPath = MountPath;
+const MountComparePath = exports.MountComparePath = function MountComparePath(target, color, id) {
+ let alpha = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;
+ const path = target.root.append('g').attr('class', 'line-clip-compare').attr('id', id).attr('clip-path', 'url(#clip)').append('path').attr('class', 'line').style('fill', 'none').style('stroke', color).style('stroke-opacity', alpha).style('stroke-width', 1).style('stroke-dasharray', '30, 3').on('click', event => (0, _compass.ClickCompass)(event, target));
+ return path;
+};
+const MountThresLine = (target, color) => {
+ const thresLineUp = target.root.append('g').attr('class', 'line-clip').attr('clip-path', 'url(#clip)').append('path').attr('class', 'thresholdUp').style('stroke-dasharray', '3, 3').style('fill', 'none').style('stroke', color).style('stroke-width', 1);
+ const thresLineDw = target.root.append('g').attr('class', 'line-clip').attr('clip-path', 'url(#clip)').append('path').attr('class', 'thresholdDw').style('stroke-dasharray', '3, 3').style('fill', 'none').style('stroke', color).style('stroke-width', 1);
+ return [thresLineUp, thresLineDw];
+};
+exports.MountThresLine = MountThresLine;
+const MountGrid = target => {
+ const gridTrans = `translate(0, ${target.h})`;
+ const xGrid = target.root.append('g').attr('class', 'x-grid').attr('transform', gridTrans);
+ const yGrid = target.root.append('g').attr('class', 'y-grid');
+ return {
+ x: xGrid,
+ y: yGrid
+ };
+};
+exports.MountGrid = MountGrid;
+const MountAxis = target => {
+ const xAxisTrans = `translate(0, ${target.h})`;
+ const xAxis = target.root.append('g').attr('class', 'x-axis').attr('transform', xAxisTrans);
+ const yAxis = target.root.append('g').attr('class', 'y-axis');
+ return {
+ x: xAxis,
+ y: yAxis
+ };
+};
+exports.MountAxis = MountAxis;
+const MountAxisLabelX = target => {
+ const xTrans = `translate(${target.w / 2}, ${target.h + 30})`;
+ target.root.append('text').attr('text-anchor', 'middle').attr('transform', xTrans).attr('class', 'xLabel').attr('font-family', 'Helvetica').style('font-size', '12px');
+};
+exports.MountAxisLabelX = MountAxisLabelX;
+const MountAxisLabelY = target => {
+ const yR = 'rotate(-90)';
+ const yTrans = `translate(${16 - target.margin.l}, ${target.h / 2}) ${yR}`;
+ target.root.append('text').attr('text-anchor', 'middle').attr('transform', yTrans).attr('class', 'yLabel').attr('font-family', 'Helvetica').style('font-size', '12px');
+};
+exports.MountAxisLabelY = MountAxisLabelY;
+const MountMarker = (target, color) => {
+ const tTrans = `translate(${target.w - 80}, -10)`;
+ const lTrans = `translate(${target.w - 200}, -18)`;
+ target.root.append('text').attr('text-anchor', 'middle').attr('transform', tTrans).attr('class', 'mark-text').attr('font-family', 'Helvetica');
+ target.root.append('rect').attr('transform', lTrans).attr('width', 30).attr('height', 5).attr('class', 'mark-line').style('fill', color);
+};
+exports.MountMarker = MountMarker;
+const MountClip = target => {
+ target.svg.append('defs').append('clipPath').attr('id', 'clip').append('rect').attr('width', target.w).attr('height', target.h).attr('x', 0).attr('y', 0);
+};
+exports.MountClip = MountClip;
+const MountMainFrame = (target, name) => {
+ const transFrame = `translate(${target.margin.l}, ${target.margin.t})`;
+ const clsName = `${name}-main`;
+ target.svg.append('g').attr('class', clsName).attr('transform', transFrame);
+};
+exports.MountMainFrame = MountMainFrame;
\ No newline at end of file
diff --git a/dist/helpers/multiplicity.js b/dist/helpers/multiplicity.js
new file mode 100644
index 00000000..c1a420b4
--- /dev/null
+++ b/dist/helpers/multiplicity.js
@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.mpyBasicPatterns = exports.groupInterval = exports.getInterval = void 0;
+const mpyBasicPatterns = exports.mpyBasicPatterns = ['s', 'd', 't', 'q', 'quint', 'h', 'sept', 'o', 'n'];
+const getInterval = peaks => {
+ let itvs = [];
+ for (let idx = 0; idx < peaks.length - 1; idx += 1) {
+ const itv = Math.abs(peaks[idx + 1].x - peaks[idx].x);
+ itvs = [...itvs, itv];
+ }
+ return itvs;
+};
+exports.getInterval = getInterval;
+const groupInterval = itvs => {
+ let gitvs = [];
+ itvs.forEach(vv => {
+ let applied = false;
+ gitvs.forEach((gv, idx) => {
+ if (applied) return;
+ if (Math.abs((gv.c - vv) / gv.c) <= 0.03) {
+ const c = (gv.c * gv.es.length + vv) / (gv.es.length + 1);
+ const es = [...gv.es, vv];
+ gitvs = [...gitvs.filter((v, i) => i !== idx), {
+ c,
+ es
+ }];
+ applied = true;
+ }
+ });
+ if (!applied) {
+ gitvs = [...gitvs, {
+ c: vv,
+ es: [vv]
+ }];
+ }
+ });
+ return gitvs;
+};
+exports.groupInterval = groupInterval;
\ No newline at end of file
diff --git a/dist/helpers/multiplicity_calc.js b/dist/helpers/multiplicity_calc.js
new file mode 100644
index 00000000..f3bce198
--- /dev/null
+++ b/dist/helpers/multiplicity_calc.js
@@ -0,0 +1,102 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.calcMpyJStr = exports.calcMpyCoup = exports.calcMpyCenter = void 0;
+var _jAnalyzer = _interopRequireDefault(require("../third_party/jAnalyzer"));
+var _multiplicity = require("./multiplicity");
+var _multiplicity_verify_basic = require("./multiplicity_verify_basic");
+/* eslint-disable prefer-object-spread, default-param-last */
+
+const centerX = (ps, shift) => {
+ const pxs = ps.map(p => p.x).sort((a, b) => a - b);
+ const centIdx = (ps.length - 1) / 2;
+ if (centIdx < 0) return 0;
+ return pxs[centIdx] - shift;
+};
+const calcMpyCenter = (ps, shift, typ) => {
+ const count = ps.length;
+ const avgX = ps.reduce((sum, nxt) => sum + nxt.x, 0) / ps.length - shift;
+ if (typ === 'm') return avgX;
+ if (count % 2 === 0) return avgX;
+ return centerX(ps, shift);
+};
+exports.calcMpyCenter = calcMpyCenter;
+const calcMpyJStr = js => {
+ if (!Array.isArray(js) || js.length === 0) return ' - ';
+ const cJ = js.map(j => j.toFixed(3)).join(', ');
+ return `${cJ}`;
+};
+exports.calcMpyJStr = calcMpyJStr;
+const calcMpyPeakWidth = (x, metaSt) => {
+ const {
+ intervalL,
+ intervalR,
+ deltaX
+ } = metaSt.peaks;
+ let idxL = null;
+ intervalL.every((l, idx) => {
+ if (l.x < x) {
+ idxL = idx - 1;
+ return false;
+ }
+ return true;
+ });
+ let idxR = null;
+ intervalR.every((l, idx) => {
+ if (l.x < x) {
+ idxR = idx;
+ return false;
+ }
+ return true;
+ });
+ if (!idxL || !idxR) return 10 * deltaX;
+ return Math.abs(intervalL[idxL].x - intervalR[idxR].x);
+};
+const calcMpyCoup = (pks, metaSt) => {
+ if (pks.length === 0) return {
+ type: '',
+ js: ''
+ };
+ const orderPks = pks.sort((a, b) => b.x - a.x);
+ const {
+ observeFrequency
+ } = metaSt.peaks;
+ const peaks = orderPks.map(p => ({
+ x: p.x,
+ intensity: p.y,
+ width: calcMpyPeakWidth(p.x, metaSt)
+ }));
+ const signal = {
+ nbPeaks: peaks.length,
+ observe: observeFrequency,
+ nucleus: '1H',
+ peaks
+ };
+ _jAnalyzer.default.compilePattern(signal);
+ const type = signal.multiplicity;
+ const js = signal.nmrJs ? signal.nmrJs.map(j => j.coupling).sort() : [];
+ const isTPCMatch = (0, _multiplicity_verify_basic.verifyTypePeakCount)(type, peaks);
+ if (!isTPCMatch) return {
+ type: 'm',
+ js: []
+ };
+ if (['s', 'm'].indexOf(type) >= 0) return {
+ type,
+ js
+ };
+ const oivs = (0, _multiplicity.getInterval)(orderPks);
+ if (type === 't') return (0, _multiplicity_verify_basic.verifyTypeT)(type, js, oivs, metaSt);
+ if (type === 'q') return (0, _multiplicity_verify_basic.verifyTypeQ)(type, js, oivs, metaSt);
+ if (type === 'quint') return (0, _multiplicity_verify_basic.verifyTypeQuint)(type, js, oivs, metaSt);
+ if (type === 'h') return (0, _multiplicity_verify_basic.verifyTypeH)(type, js, oivs, metaSt);
+ if (type === 'sept') return (0, _multiplicity_verify_basic.verifyTypeSept)(type, js, oivs, metaSt);
+ if (type === 'o') return (0, _multiplicity_verify_basic.verifyTypeO)(type, js, oivs, metaSt);
+ return {
+ type,
+ js
+ };
+};
+exports.calcMpyCoup = calcMpyCoup;
\ No newline at end of file
diff --git a/dist/helpers/multiplicity_complat.js b/dist/helpers/multiplicity_complat.js
new file mode 100644
index 00000000..66d321ed
--- /dev/null
+++ b/dist/helpers/multiplicity_complat.js
@@ -0,0 +1,100 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.calcMpyComplat = void 0;
+var _multiplicity = require("./multiplicity");
+const calcMpyComplat = origPeaks => {
+ const peaks = origPeaks.sort((a, b) => a.x - b.x);
+ const count = peaks.length;
+ const itvs = (0, _multiplicity.getInterval)(peaks);
+ const gitvs = (0, _multiplicity.groupInterval)(itvs);
+ let type = 'm';
+ let js = [];
+ switch (count) {
+ case 1:
+ type = 's';
+ js = [];
+ break;
+ case 2:
+ if (gitvs.length === 1) {
+ type = 'd';
+ js = gitvs.map(g => g.c);
+ break;
+ }
+ break;
+ case 3:
+ if (gitvs.length === 1) {
+ type = 't';
+ js = gitvs.map(g => g.c);
+ break;
+ }
+ break;
+ case 4:
+ if (gitvs.length === 1) {
+ type = 'q';
+ js = gitvs.map(g => g.c);
+ break;
+ } else if (gitvs.length === 2) {
+ type = 'dd';
+ js = gitvs.map(g => g.c);
+ break;
+ }
+ break;
+ case 5:
+ if (gitvs.length === 1) {
+ type = 'quint';
+ js = gitvs.map(g => g.c);
+ break;
+ }
+ break;
+ case 6:
+ if (gitvs.length === 1) {
+ type = 'h';
+ js = gitvs.map(g => g.c);
+ break;
+ } else if (gitvs.length === 2) {
+ type = 'dt';
+ js = gitvs.map(g => g.c);
+ break;
+ }
+ // td
+ break;
+ case 7:
+ if (gitvs.length === 1) {
+ type = 'sept';
+ js = gitvs.map(g => g.c);
+ break;
+ } else if (gitvs.length === 3) {
+ type = 'ddd';
+ js = gitvs.map(g => g.c);
+ break;
+ }
+ // td
+ break;
+ case 8:
+ if (gitvs.length === 1) {
+ type = 'o';
+ js = gitvs.map(g => g.c);
+ break;
+ } else if (gitvs.length === 2) {
+ type = 'dq';
+ js = gitvs.map(g => g.c);
+ break;
+ } else if (gitvs.length === 3) {
+ type = 'ddd';
+ js = gitvs.map(g => g.c);
+ break;
+ }
+ // td
+ break;
+ default:
+ break;
+ }
+ return {
+ type,
+ js
+ };
+};
+exports.calcMpyComplat = calcMpyComplat;
\ No newline at end of file
diff --git a/dist/helpers/multiplicity_manual.js b/dist/helpers/multiplicity_manual.js
new file mode 100644
index 00000000..e649508f
--- /dev/null
+++ b/dist/helpers/multiplicity_manual.js
@@ -0,0 +1,125 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.calcMpyManual = void 0;
+var _multiplicity = require("./multiplicity");
+/* eslint-disable prefer-object-spread, default-param-last, no-mixed-operators */
+
+const isTypeM = mpyType => mpyType === 'm';
+const isTypeBasic = mpyType => _multiplicity.mpyBasicPatterns.slice(1).indexOf(mpyType) >= 0;
+const outputTypeM = k => Object.assign({}, k, {
+ mpyType: 'm',
+ js: []
+});
+const outputTypeBasic = (k, mpyType, ivs, freq) => {
+ const numIvs = ivs.length || 1;
+ const js = [freq * ivs.reduce((sum, x) => sum + x) / numIvs];
+ return Object.assign({}, k, {
+ mpyType,
+ js
+ });
+};
+const outputTypeDD = (k, mpyType, ivs, freq) => {
+ if (ivs.length >= 2) {
+ const js = [freq * ivs[0], freq * (ivs[0] + ivs[1])];
+ return Object.assign({}, k, {
+ mpyType,
+ js
+ });
+ }
+ return Object.assign({}, k, {
+ mpyType,
+ js: []
+ });
+};
+const outputTypeDT = (k, mpyType, ivs, freq) => {
+ if (ivs.length >= 4) {
+ const js = [freq * ivs[0], freq * (ivs[1] + ivs[2] + ivs[3])];
+ return Object.assign({}, k, {
+ mpyType,
+ js
+ });
+ }
+ return Object.assign({}, k, {
+ mpyType,
+ js: []
+ });
+};
+const outputTypeTD = (k, mpyType, ivs, freq) => {
+ if (ivs.length >= 2) {
+ const js = [freq * ivs[0], freq * (ivs[0] + ivs[1])];
+ return Object.assign({}, k, {
+ mpyType,
+ js
+ });
+ }
+ return Object.assign({}, k, {
+ mpyType,
+ js: []
+ });
+};
+const outputTypeDQ = (k, mpyType, ivs, freq) => {
+ if (ivs.length >= 2) {
+ const js = [freq * ivs[0], freq * (ivs[0] + ivs[1])];
+ return Object.assign({}, k, {
+ mpyType,
+ js
+ });
+ } // only consider J = ([1,2], [1,3]), not J = ([1,2], [1,5])
+ return Object.assign({}, k, {
+ mpyType,
+ js: []
+ });
+};
+const outputTypeQD = (k, mpyType, ivs, freq) => {
+ if (ivs.length >= 2) {
+ const js = [freq * ivs[0], freq * (ivs[0] + ivs[1])];
+ return Object.assign({}, k, {
+ mpyType,
+ js
+ });
+ }
+ return Object.assign({}, k, {
+ mpyType,
+ js: []
+ });
+};
+const outputTypeDDD = (k, mpyType, ivs, freq) => {
+ if (ivs.length >= 3) {
+ const js = [freq * ivs[0], freq * (ivs[0] + ivs[1]), freq * (ivs[0] + ivs[1] + ivs[2] + ivs[3])];
+ return Object.assign({}, k, {
+ mpyType,
+ js
+ });
+ }
+ return Object.assign({}, k, {
+ mpyType,
+ js: []
+ });
+};
+const calcMpyManual = (k, mpyType, metaSt) => {
+ const {
+ observeFrequency
+ } = metaSt.peaks;
+ const freq = observeFrequency || 1.0;
+ const ivs = (0, _multiplicity.getInterval)(k.peaks);
+ if (ivs.length === 0) return Object.assign({}, k, {
+ mpyType,
+ js: []
+ });
+ if (isTypeM(mpyType)) return outputTypeM(k);
+ if (isTypeBasic(mpyType)) return outputTypeBasic(k, mpyType, ivs, freq);
+ if (mpyType === 'dd') return outputTypeDD(k, mpyType, ivs, freq);
+ if (mpyType === 'dt') return outputTypeDT(k, mpyType, ivs, freq);
+ if (mpyType === 'td') return outputTypeTD(k, mpyType, ivs, freq);
+ if (mpyType === 'dq') return outputTypeDQ(k, mpyType, ivs, freq);
+ if (mpyType === 'qd') return outputTypeQD(k, mpyType, ivs, freq);
+ if (mpyType === 'ddd') return outputTypeDDD(k, mpyType, ivs, freq);
+ return Object.assign({}, k, {
+ mpyType,
+ js: []
+ });
+};
+exports.calcMpyManual = calcMpyManual;
\ No newline at end of file
diff --git a/dist/helpers/multiplicity_verify_basic.js b/dist/helpers/multiplicity_verify_basic.js
new file mode 100644
index 00000000..f1d7df7a
--- /dev/null
+++ b/dist/helpers/multiplicity_verify_basic.js
@@ -0,0 +1,249 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.verifyTypeT = exports.verifyTypeSept = exports.verifyTypeQuint = exports.verifyTypeQ = exports.verifyTypePeakCount = exports.verifyTypeO = exports.verifyTypeH = void 0;
+/* eslint-disable prefer-object-spread, default-param-last, no-mixed-operators */
+// ---------------------------------------------------------------
+// verifyTypePeakCount
+// ---------------------------------------------------------------
+
+const verifyTypePeakCount = (type, peaks) => {
+ const isBasicWrong = type === 's' && peaks.length > 1 || type === 'd' && peaks.length > 2 || type === 't' && peaks.length > 3 || type === 'q' && peaks.length > 4 || type === 'quint' && peaks.length > 5 || type === 'h' && peaks.length > 6 || type === 'sept' && peaks.length > 7 || type === 'o' && peaks.length > 8 || type === 'n' && peaks.length > 9;
+ let limit = 1;
+ let mStr = type;
+ limit *= 5 ** (mStr.match(/quint/g) || []).length;
+ mStr = mStr.replace(/quint/g, '');
+ limit *= 7 ** (mStr.match(/sept/g) || []).length;
+ mStr = mStr.replace(/sept/g, '');
+ limit *= 2 ** (mStr.match(/d/g) || []).length;
+ mStr = mStr.replace(/d/g, '');
+ limit *= 3 ** (mStr.match(/t/g) || []).length;
+ mStr = mStr.replace(/t/g, '');
+ limit *= 4 ** (mStr.match(/q/g) || []).length;
+ mStr = mStr.replace(/q/g, '');
+ limit *= 6 ** (mStr.match(/h/g) || []).length;
+ mStr = mStr.replace(/h/g, '');
+ limit *= 8 ** (mStr.match(/o/g) || []).length;
+ mStr = mStr.replace(/o/g, '');
+ limit *= 9 ** (mStr.match(/n/g) || []).length;
+ mStr = mStr.replace(/n/g, '');
+ const isAdvanWrong = peaks.length > limit;
+ return !(isBasicWrong || isAdvanWrong);
+};
+
+// ---------------------------------------------------------------
+// Basic Multiplicity verification
+// ---------------------------------------------------------------
+exports.verifyTypePeakCount = verifyTypePeakCount;
+const allowedTolerance = 0.15;
+const faktor = 1.1;
+const passRuleIntervalCounts = (oivs, limit) => oivs.length === limit;
+const getRuleParams = (oivs, metaSt) => {
+ const {
+ deltaX,
+ observeFrequency
+ } = metaSt.peaks;
+ const sivs = [...oivs].sort((a, b) => b - a);
+ const ref = sivs[0];
+ const rDeltaX = Math.abs(2 * deltaX / ref);
+ const tTolerance = rDeltaX > allowedTolerance ? rDeltaX : allowedTolerance;
+ const tolerance = Math.abs(tTolerance * faktor);
+ const roivs = oivs.map(oiv => oiv / ref);
+ const rsivs = sivs.map(siv => siv / ref);
+ return {
+ roivs,
+ rsivs,
+ tolerance,
+ observeFrequency
+ };
+};
+const verifyTypeT = (type, js, oivs, metaSt) => {
+ if (!passRuleIntervalCounts(oivs, 2)) return {
+ type: 'm',
+ js: []
+ };
+ const {
+ rsivs,
+ tolerance
+ } = getRuleParams(oivs, metaSt);
+ const isT = Math.abs(rsivs[0] - rsivs[1]) < tolerance;
+ if (isT) return {
+ type,
+ js
+ };
+ return {
+ type: 'm',
+ js: []
+ };
+};
+exports.verifyTypeT = verifyTypeT;
+const verifyTypeQ = (type, js, oivs, metaSt) => {
+ if (!passRuleIntervalCounts(oivs, 3)) return {
+ type: 'm',
+ js: []
+ };
+ const {
+ roivs,
+ rsivs,
+ tolerance,
+ observeFrequency
+ } = getRuleParams(oivs, metaSt);
+ const isQ = Math.abs(rsivs[0] - rsivs[2]) < tolerance;
+ if (isQ) return {
+ type,
+ js
+ };
+ const isDD = Math.abs(roivs[0] - roivs[2]) < tolerance && Math.abs(roivs[0] - roivs[1]) >= tolerance;
+ const ddJs = [oivs[0] * observeFrequency, (oivs[0] + oivs[1]) * observeFrequency];
+ if (isDD) return {
+ type: 'dd',
+ js: ddJs
+ };
+ return {
+ type: 'm',
+ js: []
+ };
+};
+exports.verifyTypeQ = verifyTypeQ;
+const verifyTypeQuint = (type, js, oivs, metaSt) => {
+ if (!passRuleIntervalCounts(oivs, 4)) return {
+ type: 'm',
+ js: []
+ };
+ const {
+ rsivs,
+ tolerance
+ } = getRuleParams(oivs, metaSt);
+ const isQuint = Math.abs(rsivs[0] - rsivs[3]) < tolerance;
+ if (isQuint) return {
+ type,
+ js
+ };
+ return {
+ type: 'm',
+ js: []
+ };
+};
+exports.verifyTypeQuint = verifyTypeQuint;
+const verifyTypeH = (type, js, oivs, metaSt) => {
+ if (!passRuleIntervalCounts(oivs, 5)) return {
+ type: 'm',
+ js: []
+ };
+ const {
+ roivs,
+ rsivs,
+ tolerance,
+ observeFrequency
+ } = getRuleParams(oivs, metaSt);
+ const isH = Math.abs(rsivs[0] - rsivs[4]) < tolerance;
+ if (isH) return {
+ type,
+ js
+ };
+ const isTD = Math.abs(roivs[0] - roivs[2]) < tolerance && Math.abs(roivs[0] - roivs[4]) < tolerance && Math.abs(roivs[1] - roivs[3]) < tolerance && Math.abs(roivs[0] - roivs[1]) >= tolerance;
+ const tdJs = [oivs[0] * observeFrequency, (oivs[0] + oivs[1]) * observeFrequency];
+ if (isTD) return {
+ type: 'td',
+ js: tdJs
+ };
+ const isDT1 = Math.abs(roivs[0] - roivs[1]) < tolerance && Math.abs(roivs[0] - roivs[3]) < tolerance && Math.abs(roivs[0] - roivs[4]) < tolerance && Math.abs(roivs[0] - roivs[2]) >= tolerance;
+ const dt1Js = [oivs[0] * observeFrequency, (oivs[1] + oivs[2] + oivs[3]) * observeFrequency];
+ if (isDT1) return {
+ type: 'dt',
+ js: dt1Js
+ };
+ const isDT2 = Math.abs(roivs[0] - roivs[4]) < tolerance && Math.abs(roivs[0] - roivs[1] - roivs[2]) < tolerance && Math.abs(roivs[0] - roivs[2] - roivs[3]) < tolerance && Math.abs(roivs[0] - roivs[2]) >= tolerance;
+ const dt2Js = [oivs[0] * observeFrequency, (oivs[1] + oivs[2] + oivs[3]) * observeFrequency];
+ if (isDT2) return {
+ type: 'dt',
+ js: dt2Js
+ };
+ return {
+ type: 'm',
+ js: []
+ };
+};
+exports.verifyTypeH = verifyTypeH;
+const verifyTypeSept = (type, js, oivs, metaSt) => {
+ if (!passRuleIntervalCounts(oivs, 6)) return {
+ type: 'm',
+ js: []
+ };
+ const {
+ roivs,
+ rsivs,
+ tolerance,
+ observeFrequency
+ } = getRuleParams(oivs, metaSt);
+ const isSept = Math.abs(rsivs[0] - rsivs[5]) < tolerance;
+ if (isSept) return {
+ type,
+ js
+ };
+ const isDDD = Math.abs(roivs[0] - roivs[2]) < tolerance && Math.abs(roivs[0] - roivs[3]) < tolerance && Math.abs(roivs[0] - roivs[5]) < tolerance && Math.abs(roivs[1] - roivs[4]) < tolerance && Math.abs(roivs[0] - roivs[1]) >= tolerance;
+ const dddJs = [oivs[0] * observeFrequency, (oivs[0] + oivs[1]) * observeFrequency, (oivs[0] + oivs[1] + oivs[2]) * observeFrequency];
+ if (isDDD) return {
+ type: 'ddd',
+ js: dddJs
+ };
+ return {
+ type: 'm',
+ js: []
+ };
+};
+exports.verifyTypeSept = verifyTypeSept;
+const verifyTypeO = (type, js, oivs, metaSt) => {
+ if (!passRuleIntervalCounts(oivs, 7)) return {
+ type: 'm',
+ js: []
+ };
+ const {
+ roivs,
+ rsivs,
+ tolerance,
+ observeFrequency
+ } = getRuleParams(oivs, metaSt);
+ const isO = Math.abs(rsivs[0] - rsivs[6]) < tolerance;
+ if (isO) return {
+ type,
+ js
+ };
+ const isQD = Math.abs(roivs[0] - roivs[2]) < tolerance && Math.abs(roivs[0] - roivs[4]) < tolerance && Math.abs(roivs[0] - roivs[6]) < tolerance && Math.abs(roivs[1] - roivs[3]) < tolerance && Math.abs(roivs[1] - roivs[5]) < tolerance;
+ const qdJs = [oivs[0] * observeFrequency, (oivs[0] + oivs[1]) * observeFrequency];
+ if (isQD) return {
+ type: 'qd',
+ js: qdJs
+ };
+ const isDQ1 = Math.abs(roivs[0] - roivs[1] - roivs[2]) < tolerance && Math.abs(roivs[0] - roivs[2] - roivs[3]) < tolerance && Math.abs(roivs[0] - roivs[3] - roivs[4]) < tolerance && Math.abs(roivs[0] - roivs[4] - roivs[5]) < tolerance && Math.abs(roivs[0] - roivs[6]) < tolerance && Math.abs(roivs[1] - roivs[5]) < tolerance;
+ const dq1Js = [oivs[0] * observeFrequency, (oivs[0] + oivs[1]) * observeFrequency];
+ if (isDQ1) return {
+ type: 'dq',
+ js: dq1Js
+ };
+ const isDQ2 = Math.abs(roivs[0] - roivs[1]) < tolerance && Math.abs(roivs[0] - roivs[2]) < tolerance && Math.abs(roivs[0] - roivs[4]) < tolerance && Math.abs(roivs[0] - roivs[5]) < tolerance && Math.abs(roivs[0] - roivs[6]) < tolerance && Math.abs(roivs[0] - roivs[3]) >= tolerance;
+ const dq2Js = [oivs[0] * observeFrequency, (oivs[0] + oivs[1] + oivs[2] + oivs[3]) * observeFrequency];
+ if (isDQ2) return {
+ type: 'dq',
+ js: dq2Js
+ };
+ const isDDD1 = Math.abs(roivs[0] - roivs[2]) < tolerance && Math.abs(roivs[0] - roivs[4]) < tolerance && Math.abs(roivs[0] - roivs[6]) < tolerance && Math.abs(roivs[1] - roivs[5]) < tolerance;
+ const ddd1Js = [oivs[0] * observeFrequency, (oivs[0] + oivs[1]) * observeFrequency, (oivs[0] + oivs[1] + oivs[2] + oivs[3]) * observeFrequency];
+ if (isDDD1) return {
+ type: 'ddd',
+ js: ddd1Js
+ };
+ const isDDD2 = Math.abs(roivs[0] - roivs[2] - roivs[3]) < tolerance && Math.abs(roivs[0] - roivs[3] - roivs[4]) < tolerance && Math.abs(roivs[0] - roivs[6]) < tolerance && Math.abs(roivs[1] - roivs[5]) < tolerance && Math.abs(roivs[0] - roivs[1]) >= tolerance;
+ const ddd2Js = [oivs[0] * observeFrequency, (oivs[0] + oivs[1]) * observeFrequency, (oivs[0] + oivs[1] + oivs[2]) * observeFrequency];
+ if (isDDD2) return {
+ type: 'ddd',
+ js: ddd2Js
+ };
+ return {
+ type: 'm',
+ js: []
+ };
+};
+exports.verifyTypeO = verifyTypeO;
\ No newline at end of file
diff --git a/dist/helpers/shift.js b/dist/helpers/shift.js
new file mode 100644
index 00000000..917f161e
--- /dev/null
+++ b/dist/helpers/shift.js
@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.VirtalPts = exports.RealPts = exports.FromManualToOffset = exports.CalcResidualX = void 0;
+var _list_shift = require("../constants/list_shift");
+/* eslint-disable prefer-object-spread, default-param-last */
+
+const shiftNone = _list_shift.LIST_SHIFT_13C[0];
+const FromManualToOffset = (ref, peak) => {
+ if (!peak || ref.name === shiftNone.name) return 0;
+ const offset = peak.x - ref.value;
+ return offset || 0;
+};
+exports.FromManualToOffset = FromManualToOffset;
+const CalcResidualX = (origRef, origApex, nextApex) => {
+ if (!nextApex) return 0.0; // nextApex = false
+ if (origRef.name === shiftNone.name) return 0.0;
+ const origApexX = origApex ? origApex.x : 0.0;
+ const origShift = origApexX === 0.0 ? 0.0 : origRef.value; // orig shift
+ const resX = origShift - origApexX;
+ return resX;
+};
+exports.CalcResidualX = CalcResidualX;
+const VirtalPts = (pts, resX) => pts.map(pt => Object.assign({
+ x: pt.x + resX,
+ y: pt.y
+}));
+exports.VirtalPts = VirtalPts;
+const RealPts = (pts, resX) => pts.map(pt => Object.assign({
+ x: pt.x - resX,
+ y: pt.y
+}));
+exports.RealPts = RealPts;
\ No newline at end of file
diff --git a/dist/helpers/zoom.js b/dist/helpers/zoom.js
new file mode 100644
index 00000000..3fafd924
--- /dev/null
+++ b/dist/helpers/zoom.js
@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+const d3 = require('d3');
+const resetZoom = main => {
+ main.svg.call(main.zoom.transform, d3.zoomIdentity);
+ main.svg.selectAll('.brush').call(main.brush.move, null);
+};
+const MountZoom = (main, zoomed) => {
+ const zoomedCb = event => zoomed(event, main);
+ const resetZoomCb = event => {
+ event.stopPropagation();
+ event.preventDefault();
+ resetZoom(main);
+ };
+ main.zoom.on('zoom', zoomedCb);
+ main.svg.call(main.zoom).on('contextmenu.zoom', resetZoomCb);
+};
+var _default = exports.default = MountZoom;
\ No newline at end of file
diff --git a/dist/index.js b/dist/index.js
new file mode 100644
index 00000000..d7f7c373
--- /dev/null
+++ b/dist/index.js
@@ -0,0 +1,859 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _react = _interopRequireDefault(require("react"));
+var _reactDom = _interopRequireDefault(require("react-dom"));
+var _material = require("@mui/material");
+var _reactQuill = _interopRequireDefault(require("react-quill"));
+var _app = require("./app");
+var _nmr1h_jcamp = _interopRequireDefault(require("./__tests__/fixtures/nmr1h_jcamp"));
+var _nmr1h_2_jcamp = _interopRequireDefault(require("./__tests__/fixtures/nmr1h_2_jcamp"));
+var _nmr13c_dept_jcamp = _interopRequireDefault(require("./__tests__/fixtures/nmr13c_dept_jcamp"));
+var _nmr13c_jcamp = _interopRequireDefault(require("./__tests__/fixtures/nmr13c_jcamp"));
+var _nmr19f_jcamp = _interopRequireDefault(require("./__tests__/fixtures/nmr19f_jcamp"));
+var _nmr31p_jcamp = _interopRequireDefault(require("./__tests__/fixtures/nmr31p_jcamp"));
+var _nmr15n_jcamp = _interopRequireDefault(require("./__tests__/fixtures/nmr15n_jcamp"));
+var _nmr29si_jcamp = _interopRequireDefault(require("./__tests__/fixtures/nmr29si_jcamp"));
+var _ir_jcamp = _interopRequireDefault(require("./__tests__/fixtures/ir_jcamp"));
+var _compare_ir_1_jcamp = _interopRequireDefault(require("./__tests__/fixtures/compare_ir_1_jcamp"));
+var _compare_ir_2_jcamp = _interopRequireDefault(require("./__tests__/fixtures/compare_ir_2_jcamp"));
+var _raman_jcamp = _interopRequireDefault(require("./__tests__/fixtures/raman_jcamp"));
+var _ms_jcamp = _interopRequireDefault(require("./__tests__/fixtures/ms_jcamp"));
+var _nmr_result = _interopRequireDefault(require("./__tests__/fixtures/nmr_result"));
+var _nmr_result_alt = _interopRequireDefault(require("./__tests__/fixtures/nmr_result_alt"));
+var _ir_result = _interopRequireDefault(require("./__tests__/fixtures/ir_result"));
+var _phenylalanin = _interopRequireDefault(require("./__tests__/fixtures/phenylalanin"));
+var _compare_uv_vis_jcamp = _interopRequireDefault(require("./__tests__/fixtures/compare_uv_vis_jcamp"));
+var _uv_vis_jcamp = _interopRequireDefault(require("./__tests__/fixtures/uv_vis_jcamp"));
+var _hplc_uvvis_jcamp = _interopRequireDefault(require("./__tests__/fixtures/hplc_uvvis_jcamp"));
+var _hplc_uvvis_jcamp_ = _interopRequireDefault(require("./__tests__/fixtures/hplc_uvvis_jcamp_2"));
+var _tga_jcamp = _interopRequireDefault(require("./__tests__/fixtures/tga_jcamp"));
+var _dsc_jcamp = _interopRequireDefault(require("./__tests__/fixtures/dsc_jcamp"));
+var _xrd_jcamp_ = _interopRequireDefault(require("./__tests__/fixtures/xrd_jcamp_1"));
+var _xrd_jcamp_2 = _interopRequireDefault(require("./__tests__/fixtures/xrd_jcamp_2"));
+var _cyclic_voltammetry_ = _interopRequireDefault(require("./__tests__/fixtures/cyclic_voltammetry_1"));
+var _cyclic_voltammetry_2 = _interopRequireDefault(require("./__tests__/fixtures/cyclic_voltammetry_2"));
+var _cyclic_voltammetry_3 = _interopRequireDefault(require("./__tests__/fixtures/cyclic_voltammetry_3"));
+var _cds_jcamp = _interopRequireDefault(require("./__tests__/fixtures/cds_jcamp"));
+var _sec_1_jcamp = _interopRequireDefault(require("./__tests__/fixtures/sec_1_jcamp"));
+var _sec_2_jcamp = _interopRequireDefault(require("./__tests__/fixtures/sec_2_jcamp"));
+var _sec_3_jcamp = _interopRequireDefault(require("./__tests__/fixtures/sec_3_jcamp"));
+var _sec_4_jcamp = _interopRequireDefault(require("./__tests__/fixtures/sec_4_jcamp"));
+var _aif_jcamp_ = _interopRequireDefault(require("./__tests__/fixtures/aif_jcamp_1"));
+var _aif_jcamp_2 = _interopRequireDefault(require("./__tests__/fixtures/aif_jcamp_2"));
+var _gc_1_jcamp = _interopRequireDefault(require("./__tests__/fixtures/gc_1_jcamp"));
+var _gc_2_jcamp = _interopRequireDefault(require("./__tests__/fixtures/gc_2_jcamp"));
+var _gc_3_jcamp = _interopRequireDefault(require("./__tests__/fixtures/gc_3_jcamp"));
+var _emissions_jcamp = _interopRequireDefault(require("./__tests__/fixtures/emissions_jcamp"));
+var _dls_acf_jcamp = _interopRequireDefault(require("./__tests__/fixtures/dls_acf_jcamp"));
+var _dls_intensity_jcamp = _interopRequireDefault(require("./__tests__/fixtures/dls_intensity_jcamp"));
+var _qDescValue = require("./__tests__/fixtures/qDescValue");
+require("./__tests__/style/svg.css");
+var _jsxRuntime = require("react/jsx-runtime");
+/* eslint-disable prefer-object-spread, default-param-last, no-nested-ternary */
+
+const nmr1HEntity = _app.FN.ExtractJcamp(_nmr1h_jcamp.default);
+const nmr1HEntity2 = _app.FN.ExtractJcamp(_nmr1h_2_jcamp.default);
+const nmr13CEntity = _app.FN.ExtractJcamp(_nmr13c_jcamp.default);
+const nmr13CDeptEntity = _app.FN.ExtractJcamp(_nmr13c_dept_jcamp.default);
+const nmr19FEntity = _app.FN.ExtractJcamp(_nmr19f_jcamp.default);
+const nmr31PEntity = _app.FN.ExtractJcamp(_nmr31p_jcamp.default);
+const nmr15NEntity = _app.FN.ExtractJcamp(_nmr15n_jcamp.default);
+const nmr29SiEntity = _app.FN.ExtractJcamp(_nmr29si_jcamp.default);
+const irEntity = _app.FN.ExtractJcamp(_ir_jcamp.default);
+const compIr1Entity = _app.FN.ExtractJcamp(_compare_ir_1_jcamp.default);
+const compIr2Entity = _app.FN.ExtractJcamp(_compare_ir_2_jcamp.default);
+const ramanEntity = _app.FN.ExtractJcamp(_raman_jcamp.default);
+const msEntity = _app.FN.ExtractJcamp(_ms_jcamp.default);
+const uvVisEntity = _app.FN.ExtractJcamp(_uv_vis_jcamp.default);
+const compUvVisEntity = _app.FN.ExtractJcamp(_compare_uv_vis_jcamp.default);
+const hplcUVVisEntity = _app.FN.ExtractJcamp(_hplc_uvvis_jcamp.default);
+const hplcUVVisEntity2 = _app.FN.ExtractJcamp(_hplc_uvvis_jcamp_.default);
+const tgaEntity = _app.FN.ExtractJcamp(_tga_jcamp.default);
+const dscEntity = _app.FN.ExtractJcamp(_dsc_jcamp.default);
+const xrdEntity1 = _app.FN.ExtractJcamp(_xrd_jcamp_.default);
+const xrdEntity2 = _app.FN.ExtractJcamp(_xrd_jcamp_2.default);
+const cyclicVoltaEntity1 = _app.FN.ExtractJcamp(_cyclic_voltammetry_.default);
+const cyclicVoltaEntity2 = _app.FN.ExtractJcamp(_cyclic_voltammetry_2.default);
+const cyclicVoltaEntity3 = _app.FN.ExtractJcamp(_cyclic_voltammetry_3.default);
+const cdsEntity = _app.FN.ExtractJcamp(_cds_jcamp.default);
+const secEntity1 = _app.FN.ExtractJcamp(_sec_1_jcamp.default);
+const secEntity2 = _app.FN.ExtractJcamp(_sec_2_jcamp.default);
+const secEntity3 = _app.FN.ExtractJcamp(_sec_3_jcamp.default);
+const secEntity4 = _app.FN.ExtractJcamp(_sec_4_jcamp.default);
+const aifEntity1 = _app.FN.ExtractJcamp(_aif_jcamp_.default);
+const aifEntity2 = _app.FN.ExtractJcamp(_aif_jcamp_2.default);
+const gcEntity1 = _app.FN.ExtractJcamp(_gc_1_jcamp.default);
+const gcEntity2 = _app.FN.ExtractJcamp(_gc_2_jcamp.default);
+const gcEntity3 = _app.FN.ExtractJcamp(_gc_3_jcamp.default);
+const emissionsEntity = _app.FN.ExtractJcamp(_emissions_jcamp.default);
+const dlsAcfEntity = _app.FN.ExtractJcamp(_dls_acf_jcamp.default);
+const dlsIntensityEntity = _app.FN.ExtractJcamp(_dls_intensity_jcamp.default);
+class DemoWriteIr extends _react.default.Component {
+ constructor(props) {
+ super(props);
+ this.state = {
+ typ: 'nmr 1h',
+ desc: '',
+ predictions: false,
+ molecule: '',
+ showOthers: false,
+ descChanged: ''
+ };
+ this.onClick = this.onClick.bind(this);
+ this.writeMpy = this.writeMpy.bind(this);
+ this.writePeak = this.writePeak.bind(this);
+ this.formatPks = this.formatPks.bind(this);
+ this.formatMpy = this.formatMpy.bind(this);
+ this.savePeaks = this.savePeaks.bind(this);
+ this.predictOp = this.predictOp.bind(this);
+ this.updatInput = this.updatInput.bind(this);
+ this.loadEntity = this.loadEntity.bind(this);
+ this.loadQuill = this.loadQuill.bind(this);
+ this.onShowOthers = this.onShowOthers.bind(this);
+ this.loadOthers = this.loadOthers.bind(this);
+ this.onDescriptionChanged = this.onDescriptionChanged.bind(this);
+ this.loadMultiEntities = this.loadMultiEntities.bind(this);
+ }
+ onClick(typ) {
+ return () => {
+ this.setState({
+ typ,
+ desc: '',
+ predictions: false,
+ molecule: ''
+ });
+ };
+ }
+ onShowOthers(jcamp) {
+ // eslint-disable-line
+ this.setState({
+ showOthers: true
+ });
+ }
+ onDescriptionChanged(content) {
+ // console.log(content)
+ this.setState({
+ descChanged: content
+ });
+ }
+ loadEntity() {
+ const {
+ typ
+ } = this.state;
+ switch (typ) {
+ case 'nmr 1h':
+ return nmr1HEntity;
+ case 'nmr 13c':
+ return nmr13CEntity;
+ case 'nmr 13c dept':
+ return nmr13CDeptEntity;
+ case 'nmr 19f':
+ return nmr19FEntity;
+ case 'nmr 31p':
+ return nmr31PEntity;
+ case 'nmr 15n':
+ return nmr15NEntity;
+ case 'nmr 29si':
+ return nmr29SiEntity;
+ case 'ir':
+ return irEntity;
+ case 'raman':
+ return ramanEntity;
+ case 'uv/vis':
+ return uvVisEntity;
+ case 'hplc uv/vis':
+ return hplcUVVisEntity;
+ case 'tga':
+ return tgaEntity;
+ case 'dsc':
+ return dscEntity;
+ case 'xrd':
+ return xrdEntity1;
+ case 'cyclic volta':
+ return cyclicVoltaEntity2;
+ case 'cds':
+ return cdsEntity;
+ case 'sec':
+ return secEntity1;
+ case 'aif':
+ return aifEntity1;
+ case 'emissions':
+ return emissionsEntity;
+ case 'dls acf':
+ return dlsAcfEntity;
+ case 'dls intensity':
+ return dlsIntensityEntity;
+ case 'gc':
+ return gcEntity1;
+ case 'ms':
+ default:
+ return msEntity;
+ }
+ }
+ loadMultiEntities() {
+ const {
+ typ
+ } = this.state;
+ switch (typ) {
+ case 'cyclic volta':
+ return [cyclicVoltaEntity1, cyclicVoltaEntity2, cyclicVoltaEntity3];
+ case 'multi':
+ return [nmr1HEntity, nmr1HEntity2];
+ case 'multi hplc':
+ return [hplcUVVisEntity, hplcUVVisEntity2];
+ case 'multi ir':
+ return [compIr1Entity, compIr2Entity];
+ case 'multi xrd':
+ return [xrdEntity1, xrdEntity2];
+ case 'sec':
+ return [secEntity1, secEntity2, secEntity3, secEntity4];
+ case 'aif':
+ return [aifEntity1, aifEntity2];
+ case 'gc':
+ return [gcEntity1, gcEntity2, gcEntity3];
+ default:
+ return false;
+ }
+ }
+ loadQuill() {
+ const {
+ typ
+ } = this.state;
+ switch (typ) {
+ case 'nmr 1h':
+ return _qDescValue.q1H;
+ case 'nmr 13c':
+ return _qDescValue.q13C;
+ case 'nmr 13c dept':
+ return _qDescValue.q13C;
+ case 'ir':
+ return _qDescValue.qIR;
+ case 'nmr 19f':
+ case 'nmr 31p':
+ case 'nmr 15n':
+ case 'nmr 29si':
+ case 'raman':
+ case 'uv/vis':
+ case 'hplc uv/vis':
+ case 'tga':
+ case 'dsc':
+ case 'xrd':
+ case 'ms':
+ case 'cyclic volta':
+ case 'cds':
+ case 'sec':
+ case 'aif':
+ case 'emissions':
+ case 'dls acf':
+ case 'dls intensity':
+ case 'gc':
+ default:
+ return false;
+ }
+ }
+ loadOthers() {
+ const {
+ showOthers,
+ typ
+ } = this.state;
+ const isIr = typ === 'ir' || typ === 'multi ir';
+ const isXRD = typ === 'xrd';
+ const others = showOthers ? isIr ? [compIr1Entity, compIr2Entity] : isXRD ? [xrdEntity2] : [compUvVisEntity] : [];
+ return {
+ others,
+ addOthersCb: this.onShowOthers
+ };
+ }
+ rmDollarSign(target) {
+ return target.replace(/\$/g, '');
+ }
+ formatPks(_ref) {
+ let {
+ peaks,
+ layout,
+ shift,
+ isAscend,
+ decimal,
+ isIntensity,
+ integration,
+ waveLength,
+ cyclicvoltaSt,
+ curveSt
+ } = _ref;
+ const entity = this.loadEntity();
+ const {
+ features
+ } = entity;
+ const {
+ temperature
+ } = entity;
+ const {
+ maxY,
+ minY
+ } = Array.isArray(features) ? {} : features.editPeak || features.autoPeak;
+ const boundary = {
+ maxY,
+ minY
+ };
+ const body = _app.FN.peaksBody({
+ peaks,
+ layout,
+ decimal,
+ shift,
+ isAscend,
+ isIntensity,
+ boundary,
+ integration,
+ waveLength,
+ temperature
+ });
+ const wrapper = _app.FN.peaksWrapper(layout, shift);
+ let desc = this.rmDollarSign(wrapper.head) + body + wrapper.tail;
+ if (_app.FN.isCyclicVoltaLayout(layout)) {
+ const {
+ spectraList
+ } = cyclicvoltaSt;
+ const {
+ curveIdx,
+ listCurves
+ } = curveSt;
+ const selectedVolta = spectraList[curveIdx];
+ const selectedCurve = listCurves[curveIdx];
+ const {
+ feature
+ } = selectedCurve;
+ const {
+ scanRate
+ } = feature;
+ const data = {
+ scanRate,
+ voltaData: {
+ listPeaks: selectedVolta.list,
+ xyData: feature.data[0]
+ }
+ };
+ const inlineData = _app.FN.inlineNotation(layout, data);
+ const {
+ formattedString
+ } = inlineData;
+ desc = formattedString;
+ }
+ return desc;
+ }
+ formatMpy(_ref2) {
+ let {
+ multiplicity,
+ integration,
+ shift,
+ isAscend,
+ decimal,
+ layout
+ } = _ref2;
+ // obsv freq
+ const entity = this.loadEntity();
+ const {
+ features
+ } = entity;
+ const {
+ observeFrequency
+ } = Array.isArray(features) ? features[0] : features.editPeak || features.autoPeak;
+ const freq = observeFrequency[0];
+ const freqStr = freq ? `${parseInt(freq, 10)} MHz, ` : '';
+ // multiplicity
+ const {
+ refArea,
+ refFactor
+ } = integration;
+ const shiftVal = multiplicity.shift;
+ const ms = multiplicity.stack;
+ const is = integration.stack;
+ const macs = ms.map(m => {
+ const {
+ peaks,
+ mpyType,
+ xExtent
+ } = m;
+ const {
+ xL,
+ xU
+ } = xExtent;
+ const it = is.filter(i => i.xL === xL && i.xU === xU)[0] || {
+ area: 0
+ };
+ const area = it.area * refFactor / refArea; // eslint-disable-line
+ const center = _app.FN.calcMpyCenter(peaks, shiftVal, mpyType);
+ const xs = m.peaks.map(p => p.x).sort((a, b) => a - b);
+ const [aIdx, bIdx] = isAscend ? [0, xs.length - 1] : [xs.length - 1, 0];
+ const mxA = mpyType === 'm' ? (xs[aIdx] - shiftVal).toFixed(decimal) : 0;
+ const mxB = mpyType === 'm' ? (xs[bIdx] - shiftVal).toFixed(decimal) : 0;
+ return Object.assign({}, m, {
+ area,
+ center,
+ mxA,
+ mxB
+ });
+ }).sort((a, b) => isAscend ? a.center - b.center : b.center - a.center);
+ const str = macs.map(m => {
+ const c = m.center;
+ const type = m.mpyType;
+ const it = Math.round(m.area);
+ const js = m.js.map(j => `J = ${j.toFixed(1)} Hz`).join(', ');
+ const atomCount = layout === '1H' ? `, ${it}H` : '';
+ const location = type === 'm' ? `${m.mxA}–${m.mxB}` : `${c.toFixed(decimal)}`;
+ return m.js.length === 0 ? `${location} (${type}${atomCount})` : `${location} (${type}, ${js}${atomCount})`;
+ }).join(', ');
+ const {
+ label,
+ value,
+ name
+ } = shift.ref;
+ const solvent = label ? `${name.split('(')[0].trim()} [${value.toFixed(decimal)} ppm], ` : '';
+ return `${layout} NMR (${freqStr}${solvent}ppm) δ = ${str}.`;
+ }
+ writeMpy(_ref3) {
+ let {
+ layout,
+ shift,
+ isAscend,
+ decimal,
+ multiplicity,
+ integration
+ } = _ref3;
+ if (!_app.FN.isNmrLayout(layout)) return;
+ const desc = this.formatMpy({
+ multiplicity,
+ integration,
+ shift,
+ isAscend,
+ decimal,
+ layout
+ });
+ this.setState({
+ desc
+ });
+ }
+ writePeak(_ref4) {
+ let {
+ peaks,
+ layout,
+ shift,
+ isAscend,
+ decimal,
+ isIntensity,
+ integration,
+ waveLength,
+ cyclicvoltaSt,
+ curveSt
+ } = _ref4;
+ const desc = this.formatPks({
+ peaks,
+ layout,
+ shift,
+ isAscend,
+ decimal,
+ isIntensity,
+ integration,
+ waveLength,
+ // eslint-disable-line
+ cyclicvoltaSt,
+ curveSt // eslint-disable-line
+ });
+ this.setState({
+ desc
+ });
+ }
+ savePeaks(_ref5) {
+ let {
+ peaks,
+ layout,
+ shift,
+ isAscend,
+ decimal,
+ analysis,
+ isIntensity,
+ integration,
+ multiplicity,
+ waveLength
+ } = _ref5;
+ const entity = this.loadEntity();
+ const {
+ features
+ } = entity;
+ const {
+ temperature
+ } = entity;
+ const {
+ maxY,
+ minY
+ } = Array.isArray(features) ? features[0] : features.editPeak || features.autoPeak;
+ const boundary = {
+ maxY,
+ minY
+ };
+ const body = _app.FN.peaksBody({
+ peaks,
+ layout,
+ decimal,
+ shift,
+ isAscend,
+ isIntensity,
+ boundary,
+ waveLength,
+ temperature
+ });
+ /*eslint-disable */
+ console.log(analysis);
+ console.log(integration);
+ console.log(multiplicity);
+ if (shift.ref.label) {
+ const label = this.rmDollarSign(shift.ref.label);
+ alert(`Peaks: ${body}` + '\n' + '- - - - - - - - - - -' + '\n' + `Shift solvent = ${label}, ${shift.ref.value}ppm` + '\n');
+ } else {
+ alert(`Peaks: ${body}` + '\n');
+ }
+ /*eslint-disable */
+ }
+ predictOp(_ref6) {
+ let {
+ multiplicity,
+ curveSt
+ } = _ref6;
+ const {
+ curveIdx = 0
+ } = curveSt || {};
+ const {
+ multiplicities
+ } = multiplicity;
+ const selectedMultiplicity = multiplicities[curveIdx];
+ const {
+ stack,
+ shift
+ } = selectedMultiplicity;
+ const targets = stack.map(stk => {
+ const {
+ mpyType,
+ peaks
+ } = stk;
+ return _app.FN.CalcMpyCenter(peaks, shift, mpyType);
+ });
+ // console.log(targets)
+ const {
+ molecule,
+ typ
+ } = this.state;
+ const predictions = {
+ running: true,
+ curveIdx
+ };
+ this.setState({
+ predictions
+ });
+ // simulate fetching...
+ const selectNmrResult = idx => idx % 2 === 0 ? _nmr_result.default : _nmr_result_alt.default;
+ const result = typ === 'ir' || typ === 'multi ir' ? _ir_result.default : selectNmrResult(curveIdx);
+ setTimeout(() => {
+ this.setState({
+ predictions: {
+ ...result,
+ curveIdx
+ }
+ });
+ }, 2000);
+ }
+ updatInput(e) {
+ const molecule = e.target.value;
+ this.setState({
+ molecule
+ });
+ }
+ render() {
+ const {
+ desc,
+ predictions,
+ molecule,
+ typ
+ } = this.state;
+ const entity = this.loadEntity();
+ const qDescVal = this.loadQuill();
+ const multiEntities = this.loadMultiEntities();
+ let operations = [{
+ name: 'write peaks',
+ value: this.writePeak
+ }, {
+ name: 'save',
+ value: this.savePeaks
+ }].filter(r => r.value);
+ if (_app.FN.isNmrLayout(entity.layout)) {
+ operations = [{
+ name: 'write multiplicity',
+ value: this.writeMpy
+ }, ...operations];
+ }
+ const refreshCb = () => alert('Refresch simulation!');
+ const forecast = {
+ btnCb: this.predictOp,
+ refreshCb,
+ inputCb: this.updatInput,
+ molecule: molecule,
+ predictions
+ };
+ const molSvg = ['nmr 1h', 'ir', 'cyclic volta'].indexOf(typ) >= 0 ? _phenylalanin.default.path : '';
+ const others = this.loadOthers();
+ return /*#__PURE__*/(0, _jsxRuntime.jsxs)("div", {
+ style: {
+ width: Math.round(window.innerWidth * 0.96)
+ },
+ children: [/*#__PURE__*/(0, _jsxRuntime.jsxs)("div", {
+ style: {
+ margin: '0 0 15px 55px'
+ },
+ children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Button, {
+ variant: "contained",
+ style: {
+ margin: '0 10px 0 10px'
+ },
+ onClick: this.onClick('nmr 1h'),
+ children: "NMR 1H"
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Button, {
+ variant: "contained",
+ style: {
+ margin: '0 10px 0 10px'
+ },
+ onClick: this.onClick('nmr 13c'),
+ children: "NMR 13C"
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Button, {
+ variant: "contained",
+ style: {
+ margin: '0 10px 0 10px'
+ },
+ onClick: this.onClick('nmr 13c dept'),
+ children: "NMR 13C DEPT"
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Button, {
+ variant: "contained",
+ style: {
+ margin: '0 10px 0 10px'
+ },
+ onClick: this.onClick('nmr 19f'),
+ children: "NMR 19F"
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Button, {
+ variant: "contained",
+ style: {
+ margin: '0 10px 0 10px'
+ },
+ onClick: this.onClick('nmr 31p'),
+ children: "NMR 31P"
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Button, {
+ variant: "contained",
+ style: {
+ margin: '0 10px 0 10px'
+ },
+ onClick: this.onClick('nmr 15n'),
+ children: "NMR 15N"
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Button, {
+ variant: "contained",
+ style: {
+ margin: '0 10px 0 10px'
+ },
+ onClick: this.onClick('nmr 29si'),
+ children: "NMR 29Si"
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Button, {
+ variant: "contained",
+ style: {
+ margin: '0 10px 0 10px'
+ },
+ onClick: this.onClick('ir'),
+ children: "IR"
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Button, {
+ variant: "contained",
+ style: {
+ margin: '0 10px 0 10px'
+ },
+ onClick: this.onClick('raman'),
+ children: "RAMAN"
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Button, {
+ id: "btn-uv-vis",
+ variant: "contained",
+ style: {
+ margin: '0 10px 0 10px'
+ },
+ onClick: this.onClick('uv/vis'),
+ children: "UV/VIS"
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Button, {
+ id: "btn-hplc",
+ variant: "contained",
+ style: {
+ margin: '0 10px 0 10px'
+ },
+ onClick: this.onClick('hplc uv/vis'),
+ children: "HPLC UV/VIS"
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Button, {
+ id: "btn-tga",
+ variant: "contained",
+ style: {
+ margin: '0 10px 0 10px'
+ },
+ onClick: this.onClick('tga'),
+ children: "TGA"
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Button, {
+ id: "btn-dsc",
+ variant: "contained",
+ style: {
+ margin: '0 10px 0 10px'
+ },
+ onClick: this.onClick('dsc'),
+ children: "DSC"
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Button, {
+ id: "btn-xrd",
+ variant: "contained",
+ style: {
+ margin: '0 10px 0 10px'
+ },
+ onClick: this.onClick('xrd'),
+ children: "XRD"
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Button, {
+ id: "btn-cv",
+ variant: "contained",
+ style: {
+ margin: '0 10px 0 10px'
+ },
+ onClick: this.onClick('cyclic volta'),
+ children: "CV"
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Button, {
+ variant: "contained",
+ style: {
+ margin: '0 10px 0 10px'
+ },
+ onClick: this.onClick('cds'),
+ children: "CDS"
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Button, {
+ id: "btn-sec",
+ variant: "contained",
+ style: {
+ margin: '0 10px 0 10px'
+ },
+ onClick: this.onClick('sec'),
+ children: "SEC"
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Button, {
+ id: "btn-sec",
+ variant: "contained",
+ style: {
+ margin: '0 10px 0 10px'
+ },
+ onClick: this.onClick('gc'),
+ children: "GC"
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Button, {
+ id: "btn-sod",
+ variant: "contained",
+ style: {
+ margin: '0 10px 0 10px'
+ },
+ onClick: this.onClick('aif'),
+ children: "SORPTION-DESORPTION"
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Button, {
+ variant: "contained",
+ style: {
+ margin: '0 10px 0 10px'
+ },
+ onClick: this.onClick('emissions'),
+ children: "EMISSIONS"
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Button, {
+ variant: "contained",
+ style: {
+ margin: '0 10px 0 10px'
+ },
+ onClick: this.onClick('dls acf'),
+ children: "DLS ACF"
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Button, {
+ variant: "contained",
+ style: {
+ margin: '0 10px 0 10px'
+ },
+ onClick: this.onClick('dls intensity'),
+ children: "DLS intensity"
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Button, {
+ variant: "contained",
+ style: {
+ margin: '0 10px 0 10px'
+ },
+ onClick: this.onClick('ms'),
+ children: "MS"
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Button, {
+ variant: "contained",
+ style: {
+ margin: '0 10px 0 10px'
+ },
+ onClick: this.onClick('multi'),
+ children: "Multi NMR"
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Button, {
+ variant: "contained",
+ style: {
+ margin: '0 10px 0 10px'
+ },
+ onClick: this.onClick('multi ir'),
+ children: "Multi IR"
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Button, {
+ variant: "contained",
+ style: {
+ margin: '0 10px 0 10px'
+ },
+ onClick: this.onClick('multi hplc'),
+ children: "Multi HPLC"
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Button, {
+ variant: "contained",
+ style: {
+ margin: '0 10px 0 10px'
+ },
+ onClick: this.onClick('multi xrd'),
+ children: "Multi XRD"
+ })]
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_app.SpectraEditor, {
+ entity: entity,
+ multiEntities: multiEntities,
+ others: others,
+ editorOnly: false,
+ descriptions: desc,
+ canChangeDescription: true,
+ onDescriptionChanged: this.onDescriptionChanged,
+ molSvg: molSvg,
+ exactMass: '123.0',
+ userManualLink: {
+ cv: "https://www.chemotion.net/chemotionsaurus/docs/eln/chemspectra/cvanalysis"
+ },
+ forecast: forecast,
+ operations: operations
+ }), /*#__PURE__*/(0, _jsxRuntime.jsxs)("div", {
+ children: [/*#__PURE__*/(0, _jsxRuntime.jsx)("span", {
+ children: "Description Changed"
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactQuill.default, {
+ className: 'card-sv-quill',
+ value: this.state.descChanged,
+ modules: {
+ toolbar: false
+ },
+ readOnly: true
+ })]
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Grid, {
+ container: true,
+ children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.Grid, {
+ item: true,
+ xs: 10,
+ children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_material.InputBase, {
+ style: {
+ margin: '0 0 0 63px'
+ },
+ placeholder: "Description",
+ multiline: true,
+ fullWidth: true,
+ rows: "2",
+ margin: "dense",
+ value: desc
+ })
+ })
+ })]
+ });
+ }
+}
+
+// - - - DOM - - -
+_reactDom.default.render( /*#__PURE__*/(0, _jsxRuntime.jsx)(DemoWriteIr, {}), document.getElementById('root'));
\ No newline at end of file
diff --git a/dist/layer_content.js b/dist/layer_content.js
new file mode 100644
index 00000000..abcffa17
--- /dev/null
+++ b/dist/layer_content.js
@@ -0,0 +1,105 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _reactRedux = require("react-redux");
+var _redux = require("redux");
+var _index = _interopRequireDefault(require("./components/d3_line/index"));
+var _index2 = _interopRequireDefault(require("./components/d3_rect/index"));
+var _forecast_viewer = _interopRequireDefault(require("./components/forecast_viewer"));
+var _format = _interopRequireDefault(require("./helpers/format"));
+var _jsxRuntime = require("react/jsx-runtime");
+/* eslint-disable prefer-object-spread, default-param-last, react/function-component-definition */
+
+const extractLayout = (forecast, layoutSt) => {
+ const isEmpty = Object.keys(forecast).length === 0 && forecast.constructor === Object;
+ const isNmr = _format.default.isNmrLayout(layoutSt);
+ const isMs = _format.default.isMsLayout(layoutSt);
+ const isIr = _format.default.isIrLayout(layoutSt);
+ const isUvvis = _format.default.isUvVisLayout(layoutSt) || _format.default.isHplcUvVisLayout(layoutSt);
+ const isXRD = _format.default.isXRDLayout(layoutSt);
+ const showForecast = !isEmpty && (isNmr || isIr || isUvvis || isXRD);
+ return {
+ showForecast,
+ isNmr,
+ isIr,
+ isMs,
+ isUvvis,
+ isXRD
+ };
+};
+const Content = _ref => {
+ let {
+ topic,
+ feature,
+ cLabel,
+ xLabel,
+ yLabel,
+ forecast,
+ operations,
+ layoutSt
+ } = _ref;
+ const {
+ showForecast,
+ isNmr,
+ isIr,
+ isMs,
+ isUvvis,
+ isXRD
+ } = extractLayout(forecast, layoutSt);
+ if (showForecast) {
+ return /*#__PURE__*/(0, _jsxRuntime.jsx)(_forecast_viewer.default, {
+ topic: topic,
+ cLabel: cLabel,
+ xLabel: xLabel,
+ yLabel: yLabel,
+ feature: feature,
+ forecast: forecast,
+ isNmr: isNmr,
+ isIr: isIr,
+ isUvvis: isUvvis,
+ isXRD: isXRD,
+ operations: operations
+ });
+ }
+ if (isMs) {
+ return /*#__PURE__*/(0, _jsxRuntime.jsx)(_index2.default, {
+ topic: topic,
+ cLabel: cLabel,
+ xLabel: xLabel,
+ yLabel: yLabel,
+ feature: feature,
+ isHidden: false
+ });
+ }
+ return /*#__PURE__*/(0, _jsxRuntime.jsx)(_index.default, {
+ topic: topic,
+ cLabel: cLabel,
+ xLabel: xLabel,
+ yLabel: yLabel,
+ feature: feature,
+ isHidden: false
+ });
+};
+const mapStateToProps = (state, _) => (
+// eslint-disable-line
+{
+ layoutSt: state.layout
+});
+const mapDispatchToProps = dispatch => (0, _redux.bindActionCreators)({}, dispatch);
+Content.propTypes = {
+ topic: _propTypes.default.object.isRequired,
+ feature: _propTypes.default.object.isRequired,
+ cLabel: _propTypes.default.string.isRequired,
+ xLabel: _propTypes.default.string.isRequired,
+ yLabel: _propTypes.default.string.isRequired,
+ forecast: _propTypes.default.object.isRequired,
+ operations: _propTypes.default.array.isRequired,
+ layoutSt: _propTypes.default.string.isRequired
+};
+var _default = exports.default = (0, _redux.compose)((0, _reactRedux.connect)(mapStateToProps, mapDispatchToProps))(Content);
\ No newline at end of file
diff --git a/dist/layer_init.js b/dist/layer_init.js
new file mode 100644
index 00000000..44a82363
--- /dev/null
+++ b/dist/layer_init.js
@@ -0,0 +1,281 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _reactRedux = require("react-redux");
+var _redux = require("redux");
+var _styles = require("@mui/styles");
+var _submit = require("./actions/submit");
+var _manager = require("./actions/manager");
+var _meta = require("./actions/meta");
+var _jcamp = require("./actions/jcamp");
+var _layer_prism = _interopRequireDefault(require("./layer_prism"));
+var _format = _interopRequireDefault(require("./helpers/format"));
+var _multi_jcamps_viewer = _interopRequireDefault(require("./components/multi_jcamps_viewer"));
+var _curve = require("./actions/curve");
+var _jsxRuntime = require("react/jsx-runtime");
+/* eslint-disable prefer-object-spread, default-param-last */
+
+const styles = () => ({});
+class LayerInit extends _react.default.Component {
+ constructor(props) {
+ super(props);
+ this.normChange = this.normChange.bind(this);
+ this.execReset = this.execReset.bind(this);
+ this.initReducer = this.initReducer.bind(this);
+ this.updateOthers = this.updateOthers.bind(this);
+ this.updateMultiEntities = this.updateMultiEntities.bind(this);
+ this.hasSameMultiEntities = this.hasSameMultiEntities.bind(this);
+ }
+ componentDidMount() {
+ this.execReset();
+ this.initReducer();
+ this.updateOthers();
+ this.updateMultiEntities();
+ }
+ componentDidUpdate(prevProps) {
+ this.normChange(prevProps);
+ this.updateOthers();
+ const {
+ entity,
+ multiEntities
+ } = this.props;
+ const multiEntitiesChanged = !this.hasSameMultiEntities(prevProps.multiEntities, multiEntities);
+ const entityChanged = prevProps.entity !== entity;
+ if (multiEntitiesChanged || entityChanged) {
+ this.updateMultiEntities();
+ }
+ }
+ normChange(prevProps) {
+ const {
+ entity
+ } = this.props;
+ if (prevProps.entity !== entity) {
+ this.execReset();
+ }
+ }
+ execReset() {
+ const {
+ entity,
+ updateMetaPeaksAct,
+ resetInitCommonAct,
+ resetInitMsAct,
+ resetInitNmrAct,
+ resetInitCommonWithIntergationAct,
+ resetDetectorAct,
+ updateDSCMetaDataAct,
+ resetMultiplicityAct
+ } = this.props;
+ resetInitCommonAct();
+ resetDetectorAct();
+ const {
+ layout,
+ features
+ } = entity;
+ if (_format.default.isMsLayout(layout)) {
+ // const { autoPeak, editPeak } = features; // TBD
+ const autoPeak = features.autoPeak || features[0];
+ const editPeak = features.editPeak || features[0];
+ const baseFeat = editPeak || autoPeak;
+ resetInitMsAct(baseFeat);
+ } else if (_format.default.isNmrLayout(layout)) {
+ const {
+ integration,
+ multiplicity,
+ simulation
+ } = features;
+ updateMetaPeaksAct(entity);
+ resetInitNmrAct({
+ integration,
+ multiplicity,
+ simulation
+ });
+ } else if (_format.default.isHplcUvVisLayout(layout)) {
+ const {
+ integration
+ } = features;
+ updateMetaPeaksAct(entity);
+ resetInitCommonWithIntergationAct({
+ integration
+ });
+ } else if (_format.default.isDSCLayout(layout)) {
+ const {
+ dscMetaData
+ } = features;
+ updateDSCMetaDataAct(dscMetaData);
+ } else {
+ resetMultiplicityAct();
+ }
+ }
+ initReducer() {
+ const {
+ operations,
+ updateOperationAct
+ } = this.props;
+ updateOperationAct(operations[0]);
+ }
+ updateOthers() {
+ const {
+ others,
+ addOthersAct
+ } = this.props;
+ addOthersAct(others);
+ }
+ hasSameMultiEntities(prevMultiEntities, nextMultiEntities) {
+ if (prevMultiEntities === nextMultiEntities) return true;
+ const prevArray = Array.isArray(prevMultiEntities) ? prevMultiEntities : null;
+ const nextArray = Array.isArray(nextMultiEntities) ? nextMultiEntities : null;
+ if (!prevArray && !nextArray) return true;
+ if (!prevArray || !nextArray) return false;
+ if (prevArray.length !== nextArray.length) return false;
+ for (let idx = 0; idx < prevArray.length; idx += 1) {
+ if (prevArray[idx] !== nextArray[idx]) return false;
+ }
+ return true;
+ }
+ updateMultiEntities() {
+ const {
+ multiEntities,
+ setAllCurvesAct,
+ entity
+ } = this.props;
+ const isMultiSpectra = Array.isArray(multiEntities) && multiEntities.length > 1;
+ if (isMultiSpectra) {
+ setAllCurvesAct(multiEntities);
+ return;
+ }
+ if (_format.default.isCyclicVoltaLayout(entity.layout)) {
+ const payload = Array.isArray(multiEntities) && multiEntities.length > 0 ? multiEntities : [entity];
+ setAllCurvesAct(payload);
+ return;
+ }
+ setAllCurvesAct(false);
+ }
+ render() {
+ const {
+ entity,
+ cLabel,
+ xLabel,
+ yLabel,
+ forecast,
+ operations,
+ descriptions,
+ molSvg,
+ editorOnly,
+ exactMass,
+ canChangeDescription,
+ onDescriptionChanged,
+ multiEntities,
+ entityFileNames,
+ userManualLink
+ } = this.props;
+ const target = entity.spectra[0];
+ const {
+ layout
+ } = entity;
+ const xxLabel = !xLabel && xLabel === '' ? `X (${target.xUnit})` : xLabel;
+ const yyLabel = !yLabel && yLabel === '' ? `Y (${target.yUnit})` : yLabel;
+ const isMultiSpectra = Array.isArray(multiEntities) && multiEntities.length > 1;
+ if (isMultiSpectra) {
+ return /*#__PURE__*/(0, _jsxRuntime.jsx)(_multi_jcamps_viewer.default, {
+ multiEntities: multiEntities,
+ entityFileNames: entityFileNames,
+ userManualLink: userManualLink,
+ molSvg: molSvg,
+ exactMass: exactMass,
+ operations: operations,
+ forecast: forecast,
+ cLabel: cLabel,
+ descriptions: descriptions,
+ canChangeDescription: canChangeDescription,
+ onDescriptionChanged: onDescriptionChanged
+ });
+ } else if (_format.default.isCyclicVoltaLayout(layout)) {
+ // eslint-disable-line
+ return /*#__PURE__*/(0, _jsxRuntime.jsx)(_multi_jcamps_viewer.default, {
+ multiEntities: [entity],
+ entityFileNames: entityFileNames,
+ userManualLink: userManualLink,
+ molSvg: molSvg,
+ exactMass: exactMass,
+ operations: operations,
+ forecast: forecast,
+ cLabel: cLabel,
+ descriptions: descriptions,
+ canChangeDescription: canChangeDescription,
+ onDescriptionChanged: onDescriptionChanged
+ });
+ }
+ return /*#__PURE__*/(0, _jsxRuntime.jsx)(_layer_prism.default, {
+ entity: entity,
+ cLabel: cLabel,
+ xLabel: xxLabel,
+ yLabel: yyLabel,
+ forecast: forecast,
+ operations: operations,
+ descriptions: descriptions,
+ molSvg: molSvg,
+ editorOnly: editorOnly,
+ exactMass: exactMass,
+ canChangeDescription: canChangeDescription,
+ onDescriptionChanged: onDescriptionChanged
+ });
+ }
+}
+const mapStateToProps = (state, props) => (
+// eslint-disable-line
+{});
+const mapDispatchToProps = dispatch => (0, _redux.bindActionCreators)({
+ resetInitCommonAct: _manager.resetInitCommon,
+ resetInitNmrAct: _manager.resetInitNmr,
+ resetInitMsAct: _manager.resetInitMs,
+ resetInitCommonWithIntergationAct: _manager.resetInitCommonWithIntergation,
+ resetDetectorAct: _manager.resetDetector,
+ resetMultiplicityAct: _manager.resetMultiplicity,
+ updateOperationAct: _submit.updateOperation,
+ updateMetaPeaksAct: _meta.updateMetaPeaks,
+ addOthersAct: _jcamp.addOthers,
+ setAllCurvesAct: _curve.setAllCurves,
+ updateDSCMetaDataAct: _meta.updateDSCMetaData
+}, dispatch);
+LayerInit.propTypes = {
+ entity: _propTypes.default.object.isRequired,
+ multiEntities: _propTypes.default.array,
+ // eslint-disable-line
+ entityFileNames: _propTypes.default.array,
+ // eslint-disable-line
+ others: _propTypes.default.object.isRequired,
+ cLabel: _propTypes.default.string.isRequired,
+ xLabel: _propTypes.default.string.isRequired,
+ yLabel: _propTypes.default.string.isRequired,
+ molSvg: _propTypes.default.string.isRequired,
+ editorOnly: _propTypes.default.bool.isRequired,
+ exactMass: _propTypes.default.string.isRequired,
+ forecast: _propTypes.default.object.isRequired,
+ operations: _propTypes.default.array.isRequired,
+ descriptions: _propTypes.default.array.isRequired,
+ resetInitCommonAct: _propTypes.default.func.isRequired,
+ resetInitNmrAct: _propTypes.default.func.isRequired,
+ resetInitMsAct: _propTypes.default.func.isRequired,
+ resetInitCommonWithIntergationAct: _propTypes.default.func.isRequired,
+ updateOperationAct: _propTypes.default.func.isRequired,
+ updateMetaPeaksAct: _propTypes.default.func.isRequired,
+ addOthersAct: _propTypes.default.func.isRequired,
+ canChangeDescription: _propTypes.default.bool.isRequired,
+ onDescriptionChanged: _propTypes.default.func,
+ // eslint-disable-line
+ setAllCurvesAct: _propTypes.default.func.isRequired,
+ userManualLink: _propTypes.default.object,
+ // eslint-disable-line
+ resetDetectorAct: _propTypes.default.func.isRequired,
+ resetMultiplicityAct: _propTypes.default.func.isRequired,
+ updateDSCMetaDataAct: _propTypes.default.func.isRequired
+};
+var _default = exports.default = (0, _reactRedux.connect)(
+// eslint-disable-line
+mapStateToProps, mapDispatchToProps)((0, _styles.withStyles)(styles)(LayerInit)); // eslint-disable-line
\ No newline at end of file
diff --git a/dist/layer_prism.js b/dist/layer_prism.js
new file mode 100644
index 00000000..c6e5fd01
--- /dev/null
+++ b/dist/layer_prism.js
@@ -0,0 +1,151 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _reactRedux = require("react-redux");
+var _redux = require("redux");
+var _Grid = _interopRequireDefault(require("@mui/material/Grid"));
+var _styles = require("@mui/styles");
+var _index = _interopRequireDefault(require("./components/panel/index"));
+var _index2 = _interopRequireDefault(require("./components/cmd_bar/index"));
+var _layer_content = _interopRequireDefault(require("./layer_content"));
+var _list_ui = require("./constants/list_ui");
+var _extractParams = require("./helpers/extractParams");
+var _jsxRuntime = require("react/jsx-runtime");
+/* eslint-disable prefer-object-spread, default-param-last,
+react/function-component-definition, react/require-default-props
+*/
+
+const styles = () => ({});
+const LayerPrism = _ref => {
+ let {
+ entity,
+ cLabel,
+ xLabel,
+ yLabel,
+ forecast,
+ operations,
+ descriptions,
+ molSvg,
+ editorOnly,
+ exactMass,
+ thresSt,
+ scanSt,
+ uiSt,
+ canChangeDescription,
+ onDescriptionChanged
+ } = _ref;
+ const {
+ topic,
+ feature,
+ hasEdit,
+ integration
+ } = (0, _extractParams.extractParams)(entity, thresSt, scanSt);
+ if (!topic) return null;
+ const {
+ viewer
+ } = uiSt;
+ if (viewer === _list_ui.LIST_UI_VIEWER_TYPE.ANALYSIS) {
+ return /*#__PURE__*/(0, _jsxRuntime.jsxs)("div", {
+ children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_index2.default, {
+ feature: feature,
+ hasEdit: hasEdit,
+ forecast: forecast,
+ operations: operations,
+ editorOnly: editorOnly
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+ className: "react-spectrum-editor",
+ children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_Grid.default, {
+ container: true,
+ children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_Grid.default, {
+ item: true,
+ xs: 12,
+ children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_layer_content.default, {
+ topic: topic,
+ feature: feature,
+ cLabel: cLabel,
+ xLabel: xLabel,
+ yLabel: yLabel,
+ forecast: forecast,
+ operations: operations
+ })
+ })
+ })
+ })]
+ });
+ }
+ return /*#__PURE__*/(0, _jsxRuntime.jsxs)("div", {
+ children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_index2.default, {
+ feature: feature,
+ hasEdit: hasEdit,
+ forecast: forecast,
+ operations: operations,
+ editorOnly: editorOnly
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+ className: "react-spectrum-editor",
+ children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(_Grid.default, {
+ container: true,
+ children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_Grid.default, {
+ item: true,
+ xs: 9,
+ children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_layer_content.default, {
+ topic: topic,
+ feature: feature,
+ cLabel: cLabel,
+ xLabel: xLabel,
+ yLabel: yLabel,
+ forecast: forecast,
+ operations: operations
+ })
+ }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_Grid.default, {
+ item: true,
+ xs: 3,
+ align: "center",
+ children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_index.default, {
+ feature: feature,
+ integration: integration,
+ editorOnly: editorOnly,
+ molSvg: molSvg,
+ exactMass: exactMass,
+ descriptions: descriptions,
+ canChangeDescription: canChangeDescription,
+ onDescriptionChanged: onDescriptionChanged
+ })
+ })]
+ })
+ })]
+ });
+};
+const mapStateToProps = (state, props) => (
+// eslint-disable-line
+{
+ scanSt: state.scan,
+ thresSt: state.threshold.list[state.curve.curveIdx],
+ uiSt: state.ui
+});
+const mapDispatchToProps = dispatch => (0, _redux.bindActionCreators)({}, dispatch);
+LayerPrism.propTypes = {
+ entity: _propTypes.default.object.isRequired,
+ cLabel: _propTypes.default.string.isRequired,
+ xLabel: _propTypes.default.string.isRequired,
+ yLabel: _propTypes.default.string.isRequired,
+ molSvg: _propTypes.default.string.isRequired,
+ editorOnly: _propTypes.default.bool.isRequired,
+ exactMass: _propTypes.default.string,
+ forecast: _propTypes.default.object.isRequired,
+ operations: _propTypes.default.array.isRequired,
+ descriptions: _propTypes.default.array.isRequired,
+ thresSt: _propTypes.default.object.isRequired,
+ scanSt: _propTypes.default.object.isRequired,
+ uiSt: _propTypes.default.object.isRequired,
+ canChangeDescription: _propTypes.default.bool.isRequired,
+ onDescriptionChanged: _propTypes.default.func
+};
+var _default = exports.default = (0, _reactRedux.connect)(
+// eslint-disable-line
+mapStateToProps, mapDispatchToProps)((0, _styles.withStyles)(styles)(LayerPrism)); // eslint-disable-line
\ No newline at end of file
diff --git a/dist/reducers/index.js b/dist/reducers/index.js
new file mode 100644
index 00000000..50868a3b
--- /dev/null
+++ b/dist/reducers/index.js
@@ -0,0 +1,51 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+var _redux = require("redux");
+var _reducer_threshold = _interopRequireDefault(require("./reducer_threshold"));
+var _reducer_edit_peak = _interopRequireDefault(require("./reducer_edit_peak"));
+var _reducer_status = _interopRequireDefault(require("./reducer_status"));
+var _reducer_manager = _interopRequireDefault(require("./reducer_manager"));
+var _reducer_layout = _interopRequireDefault(require("./reducer_layout"));
+var _reducer_shift = _interopRequireDefault(require("./reducer_shift"));
+var _reducer_scan = _interopRequireDefault(require("./reducer_scan"));
+var _reducer_forecast = _interopRequireDefault(require("./reducer_forecast"));
+var _reducer_ui = _interopRequireDefault(require("./reducer_ui"));
+var _reducer_submit = _interopRequireDefault(require("./reducer_submit"));
+var _reducer_integration = _interopRequireDefault(require("./reducer_integration"));
+var _reducer_multiplicity = _interopRequireDefault(require("./reducer_multiplicity"));
+var _reducer_simulation = _interopRequireDefault(require("./reducer_simulation"));
+var _reducer_meta = _interopRequireDefault(require("./reducer_meta"));
+var _reducer_jcamp = _interopRequireDefault(require("./reducer_jcamp"));
+var _reducer_wavelength = _interopRequireDefault(require("./reducer_wavelength"));
+var _reducer_voltammetry = _interopRequireDefault(require("./reducer_voltammetry"));
+var _reducer_curve = _interopRequireDefault(require("./reducer_curve"));
+var _reducer_axes = _interopRequireDefault(require("./reducer_axes"));
+var _reducer_detector = _interopRequireDefault(require("./reducer_detector"));
+const rootReducer = (0, _redux.combineReducers)({
+ threshold: _reducer_threshold.default,
+ editPeak: _reducer_edit_peak.default,
+ status: _reducer_status.default,
+ manager: _reducer_manager.default,
+ layout: _reducer_layout.default,
+ shift: _reducer_shift.default,
+ scan: _reducer_scan.default,
+ forecast: _reducer_forecast.default,
+ ui: _reducer_ui.default,
+ submit: _reducer_submit.default,
+ integration: _reducer_integration.default,
+ multiplicity: _reducer_multiplicity.default,
+ simulation: _reducer_simulation.default,
+ meta: _reducer_meta.default,
+ jcamp: _reducer_jcamp.default,
+ wavelength: _reducer_wavelength.default,
+ cyclicvolta: _reducer_voltammetry.default,
+ curve: _reducer_curve.default,
+ axesUnits: _reducer_axes.default,
+ detector: _reducer_detector.default
+});
+var _default = exports.default = rootReducer;
\ No newline at end of file
diff --git a/dist/reducers/reducer_axes.js b/dist/reducers/reducer_axes.js
new file mode 100644
index 00000000..889a70a7
--- /dev/null
+++ b/dist/reducers/reducer_axes.js
@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+var _action_type = require("../constants/action_type");
+/* eslint-disable default-param-last, prefer-object-spread */
+
+const initialState = {
+ axes: [{
+ xUnit: '',
+ yUnit: ''
+ }]
+};
+const updateAxis = function updateAxis(state, payload) {
+ let isYAxis = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+ const {
+ value,
+ curveIndex
+ } = payload;
+ const {
+ axes
+ } = state;
+ let selectedAxes = axes[curveIndex];
+ if (!selectedAxes) {
+ selectedAxes = {
+ xUnit: '',
+ yUnit: ''
+ };
+ }
+ let newAxes = null;
+ if (isYAxis) {
+ newAxes = Object.assign({}, selectedAxes, {
+ yUnit: value
+ });
+ } else {
+ newAxes = Object.assign({}, selectedAxes, {
+ xUnit: value
+ });
+ }
+ axes[curveIndex] = newAxes;
+ return Object.assign({}, state, {
+ axes
+ });
+};
+const axesReducer = function axesReducer() {
+ let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+ let action = arguments.length > 1 ? arguments[1] : undefined;
+ switch (action.type) {
+ case _action_type.AXES.UPDATE_X_AXIS:
+ return updateAxis(state, action.payload);
+ case _action_type.AXES.UPDATE_Y_AXIS:
+ return updateAxis(state, action.payload, true);
+ default:
+ return state;
+ }
+};
+var _default = exports.default = axesReducer;
\ No newline at end of file
diff --git a/dist/reducers/reducer_curve.js b/dist/reducers/reducer_curve.js
new file mode 100644
index 00000000..0af10f6b
--- /dev/null
+++ b/dist/reducers/reducer_curve.js
@@ -0,0 +1,82 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+var _action_type = require("../constants/action_type");
+var _extractParams = require("../helpers/extractParams");
+var _chem = require("../helpers/chem");
+var _format = _interopRequireDefault(require("../helpers/format"));
+/* eslint-disable prefer-object-spread, default-param-last, max-len */
+
+const initialState = {
+ listCurves: [],
+ curveIdx: 0,
+ isShowAllCurve: false
+};
+const setAllCurves = (state, action) => {
+ const {
+ payload
+ } = action;
+ if (payload) {
+ const entities = payload.map((entity, idx) => {
+ const {
+ topic,
+ feature,
+ hasEdit,
+ integration,
+ multiplicity
+ } = (0, _extractParams.extractParams)(entity, {
+ isEdit: true
+ });
+ const simulation = entity && entity.features ? entity.features.simulation : undefined;
+ // const layout = entity.layout;
+ const {
+ layout
+ } = entity;
+ const maxminPeak = (0, _chem.Convert2MaxMinPeak)(layout, feature, 0);
+ const color = _format.default.mutiEntitiesColors(idx);
+ return {
+ layout,
+ topic,
+ feature,
+ hasEdit,
+ integration,
+ multiplicity,
+ simulation,
+ maxminPeak,
+ color,
+ curveIdx: idx
+ };
+ });
+ return Object.assign({}, state, {
+ curveIdx: 0,
+ listCurves: entities
+ });
+ }
+ return Object.assign({}, state, {
+ curveIdx: 0,
+ listCurves: payload
+ });
+};
+const curveReducer = function curveReducer() {
+ let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+ let action = arguments.length > 1 ? arguments[1] : undefined;
+ switch (action.type) {
+ case _action_type.CURVE.SELECT_WORKING_CURVE:
+ return Object.assign({}, state, {
+ curveIdx: action.payload
+ });
+ case _action_type.CURVE.SET_ALL_CURVES:
+ return setAllCurves(state, action);
+ case _action_type.CURVE.SET_SHOULD_SHOW_ALL_CURVES:
+ return Object.assign({}, state, {
+ isShowAllCurve: action.payload
+ });
+ default:
+ return state;
+ }
+};
+var _default = exports.default = curveReducer;
\ No newline at end of file
diff --git a/dist/reducers/reducer_detector.js b/dist/reducers/reducer_detector.js
new file mode 100644
index 00000000..8f0d76b3
--- /dev/null
+++ b/dist/reducers/reducer_detector.js
@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+var _action_type = require("../constants/action_type");
+/* eslint-disable no-case-declarations */
+/* eslint-disable default-param-last */
+
+const initialState = {
+ curves: [{
+ curveIdx: 0,
+ selectedDetector: ''
+ }]
+};
+const findCurveIndex = (curves, targetCurveIdx) => curves.findIndex(curve => curve.curveIdx === targetCurveIdx);
+const updateOrAppendCurve = (curves, targetCurveIdx, newCurve) => {
+ const existingCurveIndex = findCurveIndex(curves, targetCurveIdx);
+ if (existingCurveIndex !== -1) {
+ return curves.map((curve, index) => index === existingCurveIndex ? {
+ ...curve,
+ ...newCurve
+ } : curve);
+ }
+ return [...curves, newCurve];
+};
+const detectorReducer = function detectorReducer() {
+ let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+ let action = arguments.length > 1 ? arguments[1] : undefined;
+ switch (action.type) {
+ case _action_type.SEC.UPDATE_DETECTOR:
+ const {
+ curveIdx,
+ selectedDetector
+ } = action.payload;
+ // eslint-disable-next-line max-len
+ const updatedCurves = updateOrAppendCurve(state.curves, curveIdx, {
+ curveIdx,
+ selectedDetector
+ });
+ return {
+ ...state,
+ curves: updatedCurves
+ };
+ case _action_type.MANAGER.RESET_DETECTOR:
+ return initialState;
+ default:
+ return state;
+ }
+};
+var _default = exports.default = detectorReducer;
\ No newline at end of file
diff --git a/dist/reducers/reducer_edit_peak.js b/dist/reducers/reducer_edit_peak.js
new file mode 100644
index 00000000..f41f04a8
--- /dev/null
+++ b/dist/reducers/reducer_edit_peak.js
@@ -0,0 +1,235 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.editPeakReducer = exports.default = void 0;
+var _reduxUndo = _interopRequireDefault(require("redux-undo"));
+var _action_type = require("../constants/action_type");
+var _undo_redo_config = require("./undo_redo_config");
+var _calc = require("../helpers/calc");
+/* eslint-disable prefer-object-spread, default-param-last */
+
+const initialState = {
+ selectedIdx: 0,
+ peaks: [{
+ prevOffset: 0,
+ pos: [],
+ neg: []
+ }]
+};
+const defaultEmptyPeaks = {
+ prevOffset: 0,
+ pos: [],
+ neg: []
+};
+const addToPos = (state, action) => {
+ const {
+ peaks
+ } = state;
+ const {
+ payload
+ } = action;
+ const {
+ dataToAdd,
+ curveIdx
+ } = payload;
+ let selectedEditPeaks = peaks[curveIdx];
+ if (!selectedEditPeaks) {
+ selectedEditPeaks = defaultEmptyPeaks;
+ }
+ const oriPosState = selectedEditPeaks.pos;
+ const oriNegState = selectedEditPeaks.neg;
+ const idxN = oriNegState.findIndex(n => (0, _calc.almostEqual)(n.x, dataToAdd.x));
+ if (idxN >= 0) {
+ // rm the peak from oriNegState if it is already deleted.
+ const neg = [...oriNegState.slice(0, idxN), ...oriNegState.slice(idxN + 1)];
+ const newSelectedEditPeaks = Object.assign({}, selectedEditPeaks, {
+ neg
+ });
+ const newPeaks = [...peaks];
+ newPeaks[curveIdx] = newSelectedEditPeaks;
+ return Object.assign({}, state, {
+ peaks: newPeaks
+ });
+ }
+ const idxP = oriPosState.findIndex(p => (0, _calc.almostEqual)(p.x, dataToAdd.x));
+ if (idxP < 0) {
+ // add the peak
+ const pos = [...oriPosState, dataToAdd];
+ const newSelectedEditPeaks = Object.assign({}, selectedEditPeaks, {
+ pos
+ });
+ const newPeaks = [...peaks];
+ newPeaks[curveIdx] = newSelectedEditPeaks;
+ return Object.assign({}, state, {
+ peaks: newPeaks,
+ selectedIdx: curveIdx
+ });
+ }
+ return state;
+};
+const rmFromPos = (state, action) => {
+ const {
+ selectedIdx,
+ peaks
+ } = state;
+ const selectedEditPeaks = peaks[selectedIdx];
+ const oriPosState = selectedEditPeaks.pos;
+ const idx = oriPosState.findIndex(p => p.x === action.payload.x);
+ const pos = [...oriPosState.slice(0, idx), ...oriPosState.slice(idx + 1)];
+ const newSelectedEditPeaks = Object.assign({}, selectedEditPeaks, {
+ pos
+ });
+ const newPeaks = [...peaks];
+ newPeaks[selectedIdx] = newSelectedEditPeaks;
+ return Object.assign({}, state, {
+ peaks: newPeaks
+ });
+};
+const addToNeg = (state, action) => {
+ const {
+ peaks
+ } = state;
+ const {
+ payload
+ } = action;
+ const {
+ dataToAdd,
+ curveIdx
+ } = payload;
+ let selectedEditPeaks = peaks[curveIdx];
+ if (!selectedEditPeaks) {
+ selectedEditPeaks = defaultEmptyPeaks;
+ }
+ const oriPosState = selectedEditPeaks.pos;
+ const oriNegState = selectedEditPeaks.neg;
+ const idxP = oriPosState.findIndex(n => n.x === dataToAdd.x);
+ if (idxP >= 0) {
+ const pos = [...oriPosState.slice(0, idxP), ...oriPosState.slice(idxP + 1)];
+ const newSelectedEditPeaks = Object.assign({}, selectedEditPeaks, {
+ pos
+ });
+ const newPeaks = [...peaks];
+ newPeaks[curveIdx] = newSelectedEditPeaks;
+ return Object.assign({}, state, {
+ peaks: newPeaks
+ });
+ }
+ const idxN = oriNegState.findIndex(n => n.x === dataToAdd.x);
+ if (idxN < 0) {
+ const neg = [...oriNegState, dataToAdd];
+ const newSelectedEditPeaks = Object.assign({}, selectedEditPeaks, {
+ neg
+ });
+ const newPeaks = [...peaks];
+ newPeaks[curveIdx] = newSelectedEditPeaks;
+ return Object.assign({}, state, {
+ peaks: newPeaks,
+ selectedIdx: curveIdx
+ });
+ }
+ return state;
+};
+const rmFromNeg = (state, action) => {
+ const {
+ selectedIdx,
+ peaks
+ } = state;
+ const selectedEditPeaks = peaks[selectedIdx];
+ const oriNegState = selectedEditPeaks.neg;
+ const idx = oriNegState.findIndex(n => n.x === action.payload.x);
+ const neg = [...oriNegState.slice(0, idx), ...oriNegState.slice(idx + 1)];
+ const newSelectedEditPeaks = Object.assign({}, selectedEditPeaks, {
+ neg
+ });
+ const newPeaks = [...peaks];
+ newPeaks[selectedIdx] = newSelectedEditPeaks;
+ return Object.assign({}, state, {
+ peaks: newPeaks
+ });
+};
+const processShift = (state, action) => {
+ const {
+ payload
+ } = action;
+ const {
+ curveIdx
+ } = action.payload;
+ const {
+ peaks
+ } = state;
+ let selectedEditPeaks = peaks[curveIdx];
+ if (!selectedEditPeaks) {
+ selectedEditPeaks = defaultEmptyPeaks;
+ }
+ const {
+ pos,
+ neg,
+ prevOffset
+ } = payload;
+ const newSelectedEditPeaks = Object.assign({}, selectedEditPeaks, {
+ pos,
+ neg,
+ prevOffset
+ });
+ const newPeaks = [...peaks];
+ newPeaks[curveIdx] = newSelectedEditPeaks;
+ return Object.assign({}, state, {
+ peaks: newPeaks
+ });
+};
+const clearAllPeaks = (state, action) => {
+ const {
+ curveIdx,
+ dataPeaks
+ } = action.payload;
+ const {
+ peaks
+ } = state;
+ const selectedEditPeaks = peaks[curveIdx];
+ const {
+ pos
+ } = selectedEditPeaks;
+ const newSelectedEditPeaks = Object.assign({}, selectedEditPeaks, {
+ pos: [],
+ neg: [...pos, ...dataPeaks]
+ });
+ const newPeaks = [...peaks];
+ newPeaks[curveIdx] = newSelectedEditPeaks;
+ return Object.assign({}, state, {
+ peaks: newPeaks
+ });
+};
+const editPeakReducer = exports.editPeakReducer = function editPeakReducer() {
+ let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+ let action = arguments.length > 1 ? arguments[1] : undefined;
+ switch (action.type) {
+ case _action_type.EDITPEAK.ADD_POSITIVE:
+ return addToPos(state, action);
+ case _action_type.EDITPEAK.ADD_NEGATIVE:
+ return addToNeg(state, action);
+ case _action_type.EDITPEAK.RM_POSITIVE:
+ return rmFromPos(state, action);
+ case _action_type.EDITPEAK.RM_NEGATIVE:
+ return rmFromNeg(state, action);
+ case _action_type.EDITPEAK.SHIFT:
+ return processShift(state, action);
+ case _action_type.EDITPEAK.CLEAR_ALL:
+ return clearAllPeaks(state, action);
+ case _action_type.MANAGER.RESETALL:
+ return {
+ selectedIdx: 0,
+ peaks: [{
+ prevOffset: 0,
+ pos: [],
+ neg: []
+ }]
+ };
+ default:
+ return _undo_redo_config.undoRedoActions.indexOf(action.type) >= 0 ? Object.assign({}, state) : state;
+ }
+};
+const undoableEditPeakReducer = (0, _reduxUndo.default)(editPeakReducer, _undo_redo_config.undoRedoConfig);
+var _default = exports.default = undoableEditPeakReducer;
\ No newline at end of file
diff --git a/dist/reducers/reducer_forecast.js b/dist/reducers/reducer_forecast.js
new file mode 100644
index 00000000..e78e8239
--- /dev/null
+++ b/dist/reducers/reducer_forecast.js
@@ -0,0 +1,161 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+var _action_type = require("../constants/action_type");
+/* eslint-disable prefer-object-spread, default-param-last */
+
+const initialState = {
+ predictions: {
+ outline: {},
+ output: {
+ result: []
+ }
+ },
+ predictionsByCurve: {}
+};
+const toCurveIdx = input => Number.isInteger(input) ? input : 0;
+const getPredictionsByCurve = state => state.predictionsByCurve || {};
+const getPredictionsForCurve = (state, curveIdx) => getPredictionsByCurve(state)[curveIdx] || state.predictions;
+const updateIrResl = (stResl, plPred) => {
+ const {
+ sma,
+ identity,
+ value
+ } = plPred;
+ const {
+ svgs
+ } = stResl;
+ const prevFgs = stResl.fgs;
+ const nextVal = {
+ [`status${identity}`]: value
+ };
+ const nextFgs = prevFgs.map(fg => {
+ if (fg.sma === sma) {
+ return Object.assign({}, fg, nextVal);
+ }
+ return fg;
+ });
+ const nextResult = {
+ type: 'ir',
+ fgs: nextFgs,
+ svgs
+ };
+ return nextResult;
+};
+const updateIrStatus = (state, action) => {
+ const {
+ predictions,
+ curveIdx
+ } = action.payload;
+ const targetIdx = toCurveIdx(curveIdx);
+ const targetPredictions = getPredictionsForCurve(state, targetIdx);
+ const {
+ outline,
+ output
+ } = targetPredictions;
+ const stResl = output.result[0];
+ const nextResl = updateIrResl(stResl, predictions);
+ const nextPredictions = {
+ outline,
+ output: {
+ result: [nextResl]
+ }
+ };
+ const predictionsByCurve = Object.assign({}, getPredictionsByCurve(state), {
+ [targetIdx]: nextPredictions
+ });
+ return Object.assign({}, state, {
+ predictions: nextPredictions,
+ predictionsByCurve
+ });
+};
+const updateNmrResl = (stResl, plPred) => {
+ const {
+ idx,
+ atom,
+ identity,
+ value
+ } = plPred;
+ const preResult = stResl;
+ const nextShifts = preResult.shifts.map((s, index) => {
+ if (s.atom === atom && index === idx) {
+ return Object.assign({}, s, {
+ [`status${identity}`]: value
+ });
+ }
+ return s;
+ });
+ const nextResult = Object.assign({}, preResult, {
+ shifts: nextShifts
+ });
+ return nextResult;
+};
+const updateNmrStatus = (state, action) => {
+ const {
+ predictions,
+ curveIdx
+ } = action.payload;
+ const targetIdx = toCurveIdx(curveIdx);
+ const targetPredictions = getPredictionsForCurve(state, targetIdx);
+ const {
+ outline,
+ output
+ } = targetPredictions;
+ const stResl = output.result[0];
+ const nextResl = updateNmrResl(stResl, predictions);
+ const nextPredictions = {
+ outline,
+ output: {
+ result: [nextResl]
+ }
+ };
+ const predictionsByCurve = Object.assign({}, getPredictionsByCurve(state), {
+ [targetIdx]: nextPredictions
+ });
+ return Object.assign({}, state, {
+ predictions: nextPredictions,
+ predictionsByCurve
+ });
+};
+const forecastReducer = function forecastReducer() {
+ let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+ let action = arguments.length > 1 ? arguments[1] : undefined;
+ switch (action.type) {
+ case _action_type.FORECAST.INIT_STATUS:
+ if (!action.payload) return state;
+ {
+ const {
+ curveIdx,
+ ...payloadRest
+ } = action.payload;
+ const nextPredictions = payloadRest.predictions || state.predictions;
+ const nextState = Object.assign({}, state, payloadRest);
+ if (!Number.isInteger(curveIdx)) {
+ return nextState;
+ }
+ const predictionsByCurve = Object.assign({}, getPredictionsByCurve(state), nextPredictions ? {
+ [curveIdx]: nextPredictions
+ } : {});
+ return Object.assign({}, nextState, {
+ predictionsByCurve
+ });
+ }
+ case _action_type.FORECAST.SET_IR_STATUS:
+ return updateIrStatus(state, action);
+ case _action_type.FORECAST.SET_NMR_STATUS:
+ return updateNmrStatus(state, action);
+ case _action_type.FORECAST.CLEAR_STATUS:
+ return initialState;
+ case _action_type.MANAGER.RESETALL:
+ if (action.payload && action.payload.resetForecast) {
+ return initialState;
+ }
+ return state;
+ default:
+ return state;
+ }
+};
+var _default = exports.default = forecastReducer;
\ No newline at end of file
diff --git a/dist/reducers/reducer_integration.js b/dist/reducers/reducer_integration.js
new file mode 100644
index 00000000..50222bde
--- /dev/null
+++ b/dist/reducers/reducer_integration.js
@@ -0,0 +1,236 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+var _reduxUndo = _interopRequireDefault(require("redux-undo"));
+var _action_type = require("../constants/action_type");
+var _integration = require("../helpers/integration");
+var _undo_redo_config = require("./undo_redo_config");
+/* eslint-disable prefer-object-spread, default-param-last */
+
+const initialState = {
+ selectedIdx: 0,
+ integrations: [{
+ stack: [],
+ refArea: 1,
+ refFactor: 1,
+ shift: 0,
+ edited: false
+ }]
+};
+const defaultEmptyIntegration = {
+ stack: [],
+ refArea: 1,
+ refFactor: 1,
+ shift: 0,
+ edited: false
+};
+const addToStack = (state, action) => {
+ const {
+ newData,
+ curveIdx
+ } = action.payload;
+ const {
+ integrations
+ } = state;
+ let selectedIntegration = integrations[curveIdx];
+ if (selectedIntegration === false || selectedIntegration === undefined) {
+ selectedIntegration = defaultEmptyIntegration;
+ }
+ const {
+ stack,
+ refArea,
+ shift
+ } = selectedIntegration;
+ const {
+ xExtent,
+ data
+ } = newData;
+ const {
+ xL,
+ xU
+ } = xExtent;
+ if (!xL || !xU || xU - xL === 0) {
+ return state;
+ }
+ const area = (0, _integration.getArea)(xL, xU, data);
+ const defaultRefArea = stack.length === 0 ? area : refArea;
+ const absoluteArea = (0, _integration.getAbsoluteArea)(xL, xU, data); // area depends on y baseline
+ const newStack = [...stack, {
+ xL: xL + shift,
+ xU: xU + shift,
+ area,
+ absoluteArea
+ }];
+ const newIntegration = Object.assign({}, selectedIntegration, {
+ stack: newStack,
+ refArea: defaultRefArea
+ });
+ const newArrIntegration = [...integrations];
+ newArrIntegration[curveIdx] = newIntegration;
+ return Object.assign({}, state, {
+ integrations: newArrIntegration,
+ selectedIdx: curveIdx
+ });
+};
+const rmFromStack = (state, action) => {
+ const {
+ dataToRemove,
+ curveIdx
+ } = action.payload;
+ const {
+ xL,
+ xU,
+ xExtent
+ } = dataToRemove;
+ const {
+ integrations
+ } = state;
+ const selectedIntegration = integrations[curveIdx];
+ const {
+ stack
+ } = selectedIntegration;
+ let [txL, txU] = [0, 0];
+ if (xL && xU) {
+ // rm click integration
+ [txL, txU] = [xL, xU];
+ } else if (xExtent) {
+ // rm click multiplicity
+ [txL, txU] = [xExtent.xL, xExtent.xU];
+ } else {
+ return state;
+ }
+ const newStack = stack.filter(k => k.xL !== txL && k.xU !== txU);
+ const newIntegration = Object.assign({}, selectedIntegration, {
+ stack: newStack
+ });
+ const newArrIntegration = [...integrations];
+ newArrIntegration[curveIdx] = newIntegration;
+ return Object.assign({}, state, {
+ integrations: newArrIntegration,
+ selectedIdx: curveIdx
+ });
+};
+const setRef = (state, action) => {
+ const {
+ refData,
+ curveIdx
+ } = action.payload;
+ const {
+ integrations
+ } = state;
+ const selectedIntegration = integrations[curveIdx];
+ const {
+ stack
+ } = selectedIntegration;
+ const {
+ xL,
+ xU
+ } = refData;
+ const ref = stack.filter(k => k.xL === xL && k.xU === xU)[0];
+ if (!ref) {
+ return state;
+ }
+ const refArea = ref.area;
+ const newIntegration = Object.assign({}, selectedIntegration, {
+ refArea
+ });
+ const newArrIntegration = [...integrations];
+ newArrIntegration[curveIdx] = newIntegration;
+ return Object.assign({}, state, {
+ integrations: newArrIntegration,
+ selectedIdx: curveIdx
+ });
+};
+const setFkr = (state, action) => {
+ const {
+ payload
+ } = action;
+ const {
+ curveIdx,
+ factor
+ } = payload;
+ const {
+ integrations
+ } = state;
+ const selectedIntegration = integrations[curveIdx];
+ const val = parseFloat(factor);
+ const refFactor = val < 0.01 ? 0.01 : val;
+ const newIntegration = Object.assign({}, selectedIntegration, {
+ refFactor
+ });
+ const newArrIntegration = [...integrations];
+ newArrIntegration[curveIdx] = newIntegration;
+ return Object.assign({}, state, {
+ integrations: newArrIntegration
+ });
+};
+const setShift = (state, action) => {
+ const {
+ selectedIdx,
+ integrations
+ } = state;
+ const selectedIntegration = integrations[selectedIdx];
+ const shift = action.payload.prevOffset;
+ const newIntegration = Object.assign({}, selectedIntegration, {
+ shift
+ });
+ const newArrIntegration = [...integrations];
+ newArrIntegration[selectedIdx] = newIntegration;
+ return Object.assign({}, state, {
+ integrations: newArrIntegration
+ });
+};
+const resetAll = (state, action) => {
+ const newState = action.payload;
+ return Object.assign({}, state, newState);
+};
+const clearAll = (state, action) => {
+ const {
+ payload
+ } = action;
+ const {
+ curveIdx
+ } = payload;
+ const {
+ integrations
+ } = state;
+ const newIntegration = Object.assign({}, defaultEmptyIntegration, {
+ edited: true
+ });
+ const newArrIntegration = [...integrations];
+ newArrIntegration[curveIdx] = newIntegration;
+ return Object.assign({}, state, {
+ integrations: newArrIntegration,
+ selectedIdx: curveIdx
+ });
+};
+const integrationReducer = function integrationReducer() {
+ let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+ let action = arguments.length > 1 ? arguments[1] : undefined;
+ switch (action.type) {
+ case _action_type.UI.SWEEP.SELECT_INTEGRATION:
+ return addToStack(state, action);
+ case _action_type.INTEGRATION.RM_ONE:
+ return rmFromStack(state, action);
+ case _action_type.INTEGRATION.SET_REF:
+ return setRef(state, action);
+ case _action_type.INTEGRATION.SET_FKR:
+ return setFkr(state, action);
+ case _action_type.INTEGRATION.RESET_ALL_RDC:
+ return resetAll(state, action);
+ case _action_type.INTEGRATION.CLEAR_ALL:
+ return clearAll(state, action);
+ case _action_type.EDITPEAK.SHIFT:
+ return setShift(state, action);
+ case _action_type.MANAGER.RESETALL:
+ return state;
+ default:
+ return _undo_redo_config.undoRedoActions.indexOf(action.type) >= 0 ? Object.assign({}, state) : state;
+ }
+};
+const undoableIntegrationReducer = (0, _reduxUndo.default)(integrationReducer, _undo_redo_config.undoRedoConfig);
+var _default = exports.default = undoableIntegrationReducer;
\ No newline at end of file
diff --git a/dist/reducers/reducer_jcamp.js b/dist/reducers/reducer_jcamp.js
new file mode 100644
index 00000000..4c9c6154
--- /dev/null
+++ b/dist/reducers/reducer_jcamp.js
@@ -0,0 +1,102 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+var _action_type = require("../constants/action_type");
+/* eslint-disable prefer-object-spread, default-param-last */
+
+const initialState = {
+ selectedIdx: 0,
+ jcamps: [{
+ others: [],
+ addOthersCb: false
+ }]
+};
+const addOthers = (state, _ref) => {
+ let {
+ others,
+ addOthersCb
+ } = _ref;
+ const {
+ selectedIdx,
+ jcamps
+ } = state;
+ const selectedJcamp = jcamps[selectedIdx];
+ if (selectedJcamp.others.length > 5) return state;
+ const decoOthers = others.map(o => Object.assign({}, o, {
+ show: true
+ }));
+ const newJcamp = Object.assign({}, selectedJcamp, {
+ others: [...decoOthers].slice(0, 5),
+ addOthersCb
+ });
+ jcamps[selectedIdx] = newJcamp;
+ return Object.assign({}, state, {
+ jcamps
+ });
+};
+const rmOthersOne = (state, payload) => {
+ const {
+ selectedIdx,
+ jcamps
+ } = state;
+ const selectedJcamp = jcamps[selectedIdx];
+ const idx = payload;
+ const {
+ others
+ } = selectedJcamp;
+ const nextOther = others.filter((_, i) => i !== idx);
+ const newJcamp = Object.assign({}, selectedJcamp, {
+ others: nextOther
+ });
+ jcamps[selectedIdx] = newJcamp;
+ return Object.assign({}, state, {
+ jcamps
+ });
+};
+const toggleShow = (state, payload) => {
+ const {
+ selectedIdx,
+ jcamps
+ } = state;
+ const selectedJcamp = jcamps[selectedIdx];
+ const idx = payload;
+ const {
+ others
+ } = selectedJcamp;
+ const nextOthers = others.map((o, i) => {
+ if (i !== idx) return o;
+ const currentShow = o.show;
+ return Object.assign({}, o, {
+ show: !currentShow
+ });
+ });
+ const newJcamp = Object.assign({}, selectedJcamp, {
+ others: nextOthers
+ });
+ jcamps[selectedIdx] = newJcamp;
+ return Object.assign({}, state, {
+ jcamps
+ });
+};
+const layoutReducer = function layoutReducer() {
+ let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+ let action = arguments.length > 1 ? arguments[1] : undefined;
+ switch (action.type) {
+ case _action_type.JCAMP.ADD_OTHERS:
+ return addOthers(state, action.payload);
+ case _action_type.JCAMP.RM_OTHERS_ONE:
+ return rmOthersOne(state, action.payload);
+ case _action_type.JCAMP.TOGGLE_SHOW:
+ return toggleShow(state, action.payload);
+ case _action_type.JCAMP.CLEAR_ALL:
+ return initialState;
+ case _action_type.MANAGER.RESETALL:
+ return initialState;
+ default:
+ return state;
+ }
+};
+var _default = exports.default = layoutReducer;
\ No newline at end of file
diff --git a/dist/reducers/reducer_layout.js b/dist/reducers/reducer_layout.js
new file mode 100644
index 00000000..c981d1c0
--- /dev/null
+++ b/dist/reducers/reducer_layout.js
@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+var _action_type = require("../constants/action_type");
+var _list_layout = require("../constants/list_layout");
+/* eslint-disable prefer-object-spread, default-param-last */
+
+const initialState = _list_layout.LIST_LAYOUT.C13;
+const layoutReducer = function layoutReducer() {
+ let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+ let action = arguments.length > 1 ? arguments[1] : undefined;
+ switch (action.type) {
+ case _action_type.LAYOUT.UPDATE:
+ return action.payload;
+ case _action_type.MANAGER.RESETALL:
+ return action.payload.operation.layout;
+ default:
+ return state;
+ }
+};
+var _default = exports.default = layoutReducer;
\ No newline at end of file
diff --git a/dist/reducers/reducer_manager.js b/dist/reducers/reducer_manager.js
new file mode 100644
index 00000000..bdeabc20
--- /dev/null
+++ b/dist/reducers/reducer_manager.js
@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+/* eslint-disable prefer-object-spread, default-param-last */
+// import { MANAGER } from '../constants/action_type';
+
+const initialState = {};
+const managerReducer = function managerReducer() {
+ let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+ let action = arguments.length > 1 ? arguments[1] : undefined;
+ switch (action.type) {
+ default:
+ return state;
+ }
+};
+var _default = exports.default = managerReducer;
\ No newline at end of file
diff --git a/dist/reducers/reducer_meta.js b/dist/reducers/reducer_meta.js
new file mode 100644
index 00000000..7e1feca9
--- /dev/null
+++ b/dist/reducers/reducer_meta.js
@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+var _action_type = require("../constants/action_type");
+/* eslint-disable prefer-object-spread, default-param-last */
+
+const initialState = {
+ peaks: {
+ intervalL: null,
+ intervalR: null,
+ observeFrequency: null,
+ deltaX: null
+ },
+ dscMetaData: {
+ meltingPoint: null,
+ tg: null
+ }
+};
+const updateMetaData = (state, action) => {
+ const {
+ dscMetaData
+ } = action.payload;
+ return Object.assign({}, state, {
+ dscMetaData
+ });
+};
+const metaReducer = function metaReducer() {
+ let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+ let action = arguments.length > 1 ? arguments[1] : undefined;
+ switch (action.type) {
+ case _action_type.META.UPDATE_PEAKS_RDC:
+ return Object.assign({}, state, action.payload);
+ case _action_type.META.UPDATE_META_DATA_RDC:
+ return updateMetaData(state, action);
+ default:
+ return state;
+ }
+};
+var _default = exports.default = metaReducer;
\ No newline at end of file
diff --git a/dist/reducers/reducer_multiplicity.js b/dist/reducers/reducer_multiplicity.js
new file mode 100644
index 00000000..3b070c3f
--- /dev/null
+++ b/dist/reducers/reducer_multiplicity.js
@@ -0,0 +1,201 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+var _reduxUndo = _interopRequireDefault(require("redux-undo"));
+var _action_type = require("../constants/action_type");
+var _undo_redo_config = require("./undo_redo_config");
+/* eslint-disable prefer-object-spread, default-param-last */
+
+const initialState = {
+ selectedIdx: 0,
+ multiplicities: [{
+ stack: [],
+ shift: 0,
+ smExtext: false,
+ edited: false
+ }]
+};
+const defaultEmptyMultiplicity = {
+ stack: [],
+ shift: 0,
+ smExtext: false,
+ edited: false
+};
+const setShift = (state, action) => {
+ const shift = action.payload.prevOffset;
+ const {
+ selectedIdx,
+ multiplicities
+ } = state;
+ const selectedMulti = multiplicities[selectedIdx];
+ const newSelectedMulti = Object.assign({}, selectedMulti, {
+ shift
+ });
+ const newMultiplicities = [...multiplicities];
+ newMultiplicities[selectedIdx] = newSelectedMulti;
+ return Object.assign({}, state, {
+ multiplicities: newMultiplicities
+ });
+};
+const rmFromStack = (state, action) => {
+ const {
+ dataToRemove,
+ curveIdx
+ } = action.payload;
+ const {
+ multiplicities
+ } = state;
+ const selectedMulti = multiplicities[curveIdx];
+ const {
+ stack
+ } = selectedMulti;
+ const {
+ xL,
+ xU,
+ xExtent
+ } = dataToRemove;
+ let [txL, txU] = [0, 0];
+ if (xL && xU) {
+ // rm click integration
+ [txL, txU] = [xL, xU];
+ } else if (xExtent) {
+ // rm click multiplicity
+ [txL, txU] = [xExtent.xL, xExtent.xU];
+ } else {
+ return state;
+ }
+ const newStack = stack.filter(k => {
+ const [kxL, kxU] = [k.xExtent.xL, k.xExtent.xU];
+ return kxL !== txL && kxU !== txU;
+ });
+ const newSmExtext = newStack[0] ? newStack[0].xExtent : false;
+ const newSelectedMulti = Object.assign({}, selectedMulti, {
+ stack: newStack,
+ smExtext: newSmExtext
+ });
+ const newMultiplicities = [...multiplicities];
+ newMultiplicities[curveIdx] = newSelectedMulti;
+ return Object.assign({}, state, {
+ multiplicities: newMultiplicities,
+ selectedIdx: curveIdx
+ });
+};
+const updateMpyJ = (state, action) => {
+ const {
+ payload
+ } = action;
+ const {
+ xExtent,
+ value
+ } = payload;
+ if (!value && value !== '') return state;
+ const {
+ selectedIdx,
+ multiplicities
+ } = state;
+ const selectedMulti = multiplicities[selectedIdx];
+ const {
+ stack
+ } = selectedMulti;
+ const regx = /[^0-9.,-]/g;
+ const js = value.replace(regx, '').split(',').map(j => parseFloat(j)).filter(j => j);
+ const newStack = stack.map(k => {
+ if (k.xExtent.xL === xExtent.xL && k.xExtent.xU === xExtent.xU) {
+ if (k.mpyType === 'm') return Object.assign({}, k, {
+ js: []
+ });
+ return Object.assign({}, k, {
+ js
+ });
+ }
+ return k;
+ });
+ const newSelectedMulti = Object.assign({}, selectedMulti, {
+ stack: newStack
+ });
+ const newMultiplicities = [...multiplicities];
+ newMultiplicities[selectedIdx] = newSelectedMulti;
+ return Object.assign({}, state, {
+ multiplicities: newMultiplicities
+ });
+};
+const clickMpyOne = (state, action) => {
+ const {
+ payload
+ } = action;
+ const {
+ curveIdx,
+ payloadData
+ } = payload;
+ const {
+ multiplicities
+ } = state;
+ const selectedMulti = multiplicities[curveIdx];
+ const newSelectedMulti = Object.assign({}, selectedMulti, {
+ smExtext: payloadData
+ });
+ const newMultiplicities = [...multiplicities];
+ newMultiplicities[curveIdx] = newSelectedMulti;
+ return Object.assign({}, state, {
+ multiplicities: newMultiplicities,
+ selectedIdx: curveIdx
+ });
+};
+const clearAll = (state, action) => {
+ const {
+ payload
+ } = action;
+ const {
+ curveIdx
+ } = payload;
+ const {
+ multiplicities
+ } = state;
+ const newSelectedMulti = Object.assign({}, defaultEmptyMultiplicity, {
+ edited: true
+ });
+ const newMultiplicities = [...multiplicities];
+ newMultiplicities[curveIdx] = newSelectedMulti;
+ return Object.assign({}, state, {
+ multiplicities: newMultiplicities
+ });
+};
+const multiplicityReducer = function multiplicityReducer() {
+ let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+ let action = arguments.length > 1 ? arguments[1] : undefined;
+ switch (action.type) {
+ case _action_type.EDITPEAK.SHIFT:
+ return setShift(state, action);
+ case _action_type.INTEGRATION.RM_ONE:
+ return rmFromStack(state, action);
+ case _action_type.UI.SWEEP.SELECT_MULTIPLICITY_RDC:
+ case _action_type.MULTIPLICITY.PEAK_RM_BY_PANEL_RDC:
+ case _action_type.MULTIPLICITY.PEAK_RM_BY_UI_RDC:
+ case _action_type.MULTIPLICITY.PEAK_ADD_BY_UI_RDC:
+ case _action_type.MULTIPLICITY.RESET_ONE_RDC:
+ return action.payload;
+ case _action_type.MULTIPLICITY.UPDATE_J:
+ return updateMpyJ(state, action);
+ case _action_type.MULTIPLICITY.TYPE_SELECT_RDC:
+ return action.payload;
+ case _action_type.MULTIPLICITY.ONE_CLICK:
+ case _action_type.MULTIPLICITY.ONE_CLICK_BY_UI:
+ return clickMpyOne(state, action);
+ case _action_type.MULTIPLICITY.RESET_ALL_RDC:
+ return action.payload;
+ case _action_type.MULTIPLICITY.CLEAR_ALL:
+ return clearAll(state, action);
+ case _action_type.MANAGER.RESETALL:
+ return state;
+ case _action_type.MANAGER.RESET_MULTIPLICITY:
+ return initialState;
+ default:
+ return _undo_redo_config.undoRedoActions.indexOf(action.type) >= 0 ? Object.assign({}, state) : state;
+ }
+};
+const undoableMultiplicityReducer = (0, _reduxUndo.default)(multiplicityReducer, _undo_redo_config.undoRedoConfig);
+var _default = exports.default = undoableMultiplicityReducer;
\ No newline at end of file
diff --git a/dist/reducers/reducer_scan.js b/dist/reducers/reducer_scan.js
new file mode 100644
index 00000000..34c03273
--- /dev/null
+++ b/dist/reducers/reducer_scan.js
@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+var _action_type = require("../constants/action_type");
+/* eslint-disable prefer-object-spread, default-param-last */
+
+const initialState = {
+ target: false,
+ count: 1,
+ isAuto: true
+};
+const setTarget = (state, payload) => Object.assign({}, state, {
+ target: payload
+});
+const resetAll = (state, payload) => {
+ const {
+ scanCount,
+ scanEditTarget
+ } = payload;
+ return Object.assign({}, state, {
+ target: false,
+ count: parseInt(scanCount, 10),
+ isAuto: !scanEditTarget
+ });
+};
+const toggleIsAuto = state => Object.assign({}, state, {
+ isAuto: !state.isAuto,
+ target: false
+});
+const scanReducer = function scanReducer() {
+ let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+ let action = arguments.length > 1 ? arguments[1] : undefined;
+ switch (action.type) {
+ case _action_type.SCAN.SET_TARGET:
+ case _action_type.SCAN.RESET_TARGET:
+ return setTarget(state, action.payload);
+ case _action_type.SCAN.TOGGLE_ISAUTO:
+ return toggleIsAuto(state);
+ case _action_type.MANAGER.RESET_INIT_MS:
+ return resetAll(state, action.payload);
+ default:
+ return state;
+ }
+};
+var _default = exports.default = scanReducer;
\ No newline at end of file
diff --git a/dist/reducers/reducer_shift.js b/dist/reducers/reducer_shift.js
new file mode 100644
index 00000000..a5b0fc7c
--- /dev/null
+++ b/dist/reducers/reducer_shift.js
@@ -0,0 +1,245 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+var _action_type = require("../constants/action_type");
+var _list_shift = require("../constants/list_shift");
+var _shift = require("../helpers/shift");
+/* eslint-disable prefer-object-spread, default-param-last */
+
+const shiftNone = _list_shift.LIST_SHIFT_1H[0];
+
+// const initialState = {
+// ref: shiftNone,
+// peak: false,
+// enable: true,
+// };
+
+const initialState = {
+ selectedIdx: 0,
+ shifts: [{
+ ref: shiftNone,
+ peak: false,
+ enable: true
+ }]
+};
+const defaultEmptyShift = {
+ ref: shiftNone,
+ peak: false,
+ enable: true
+};
+const resetRef = payload => {
+ const {
+ shift,
+ layout
+ } = payload;
+ if (!shift || !shift.solventName || !shift.solventValue) return shiftNone;
+ const name = shift.solventName;
+ let target = false;
+ const listShift = (0, _list_shift.getListShift)(layout);
+ listShift.forEach(l => {
+ if (l.name === name) {
+ target = l;
+ }
+ });
+ return target || shiftNone[0];
+};
+const resetEnable = payload => {
+ const {
+ typ
+ } = payload.operation;
+ switch (typ) {
+ case 'NMR':
+ return true;
+ default:
+ return false;
+ }
+};
+const resetShift = (state, action) => {
+ const {
+ payload
+ } = action;
+ const {
+ curvesInfo
+ } = payload;
+ const {
+ isMultiCurve,
+ curveIdx,
+ numberOfCurve
+ } = curvesInfo;
+ const {
+ shifts
+ } = state;
+ let selectedShift = shifts[curveIdx];
+ if (selectedShift === false || selectedShift === undefined) {
+ selectedShift = defaultEmptyShift;
+ }
+ if (isMultiCurve) {
+ for (let idx = 0; idx < numberOfCurve; idx += 1) {
+ const checkShift = shifts[idx];
+ if (!checkShift) {
+ shifts[idx] = defaultEmptyShift;
+ }
+ }
+ }
+ const newShift = Object.assign({}, defaultEmptyShift, {
+ ref: resetRef(payload),
+ enable: resetEnable(payload)
+ });
+ shifts[curveIdx] = newShift;
+ return Object.assign({}, state, {
+ shifts,
+ selectedIdx: curveIdx
+ });
+};
+const updateShift = (state, action) => {
+ // eslint-disable-line
+ const {
+ selectedIdx,
+ shifts
+ } = state;
+ let selectedShift = shifts[selectedIdx];
+ if (selectedShift === false || selectedShift === undefined) {
+ selectedShift = defaultEmptyShift;
+ }
+ const newShift = Object.assign({}, selectedShift, {
+ ref: false,
+ enable: selectedShift.enable
+ });
+ shifts[selectedIdx] = newShift;
+ return Object.assign({}, state, {
+ shifts,
+ selectedIdx
+ });
+};
+const setRef = (state, action) => {
+ const {
+ payload
+ } = action;
+ const {
+ dataToSet,
+ curveIdx
+ } = payload;
+ const {
+ shifts
+ } = state;
+ let selectedShift = shifts[curveIdx];
+ if (selectedShift === false || selectedShift === undefined) {
+ selectedShift = defaultEmptyShift;
+ }
+ const newShift = Object.assign({}, selectedShift, {
+ ref: dataToSet,
+ enable: true
+ });
+ shifts[curveIdx] = newShift;
+ return Object.assign({}, state, {
+ shifts,
+ selectedIdx: curveIdx
+ });
+};
+const setPeak = (state, action) => {
+ const {
+ payload
+ } = action;
+ const {
+ dataToSet,
+ curveIdx
+ } = payload;
+ const {
+ shifts
+ } = state;
+ let selectedShift = shifts[curveIdx];
+ if (selectedShift === false || selectedShift === undefined) {
+ selectedShift = defaultEmptyShift;
+ }
+ const resX = (0, _shift.CalcResidualX)(selectedShift.ref, selectedShift.peak, dataToSet);
+ const trueApex = (0, _shift.RealPts)([dataToSet], resX)[0];
+ const isSamePt = selectedShift.peak.x === trueApex.x;
+ const truePeak = trueApex && trueApex.x && !isSamePt ? trueApex : false;
+ const newShift = Object.assign({}, selectedShift, {
+ peak: truePeak,
+ enable: true
+ });
+ shifts[curveIdx] = newShift;
+ return Object.assign({}, state, {
+ shifts,
+ selectedIdx: curveIdx
+ });
+};
+const removePeak = (state, action) => {
+ // eslint-disable-line
+ const {
+ selectedIdx,
+ shifts
+ } = state;
+ let selectedShift = shifts[selectedIdx];
+ if (selectedShift === false || selectedShift === undefined) {
+ selectedShift = defaultEmptyShift;
+ }
+ const newShift = Object.assign({}, selectedShift, {
+ peak: false,
+ enable: true
+ });
+ shifts[selectedIdx] = newShift;
+ return Object.assign({}, state, {
+ shifts,
+ selectedIdx
+ });
+};
+const addNegative = (state, action) => {
+ const {
+ payload
+ } = action;
+ const {
+ dataToAdd,
+ curveIdx
+ } = payload;
+ const {
+ shifts
+ } = state;
+ let selectedShift = shifts[curveIdx];
+ if (selectedShift === false || selectedShift === undefined) {
+ selectedShift = defaultEmptyShift;
+ }
+ const rmApex = selectedShift.peak.x === dataToAdd.x;
+ if (!rmApex) {
+ return state;
+ }
+ const newShift = Object.assign({}, selectedShift, {
+ peak: false,
+ enable: true
+ });
+ shifts[curveIdx] = newShift;
+ return Object.assign({}, state, {
+ shifts,
+ selectedIdx: curveIdx
+ });
+};
+const shiftReducer = function shiftReducer() {
+ let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+ let action = arguments.length > 1 ? arguments[1] : undefined;
+ switch (action.type) {
+ case _action_type.SHIFT.SET_REF:
+ return setRef(state, action);
+ case _action_type.SHIFT.SET_PEAK:
+ {
+ return setPeak(state, action);
+ }
+ case _action_type.SHIFT.RM_PEAK:
+ return removePeak(state, action);
+ case _action_type.EDITPEAK.ADD_NEGATIVE:
+ {
+ return addNegative(state, action);
+ }
+ case _action_type.LAYOUT.UPDATE:
+ return updateShift(initialState, action);
+ case _action_type.MANAGER.RESETSHIFT:
+ // case MANAGER.RESETALL:
+ return resetShift(initialState, action);
+ default:
+ return state;
+ }
+};
+var _default = exports.default = shiftReducer;
\ No newline at end of file
diff --git a/dist/reducers/reducer_simulation.js b/dist/reducers/reducer_simulation.js
new file mode 100644
index 00000000..0cd31f80
--- /dev/null
+++ b/dist/reducers/reducer_simulation.js
@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+var _action_type = require("../constants/action_type");
+/* eslint-disable prefer-object-spread, default-param-last */
+
+const initialState = {
+ nmrSimPeaks: []
+};
+const resetAll = (state, action) => {
+ const newState = action.payload;
+ return Object.assign({}, state, newState);
+};
+const simulatioinReducer = function simulatioinReducer() {
+ let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+ let action = arguments.length > 1 ? arguments[1] : undefined;
+ switch (action.type) {
+ case _action_type.SIMULATION.RESET_ALL_RDC:
+ return resetAll(state, action);
+ default:
+ return state;
+ }
+};
+var _default = exports.default = simulatioinReducer;
\ No newline at end of file
diff --git a/dist/reducers/reducer_status.js b/dist/reducers/reducer_status.js
new file mode 100644
index 00000000..53271517
--- /dev/null
+++ b/dist/reducers/reducer_status.js
@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+var _action_type = require("../constants/action_type");
+/* eslint-disable prefer-object-spread, default-param-last */
+
+const initialState = {
+ btnSubmit: false
+};
+const statusReducer = function statusReducer() {
+ let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+ let action = arguments.length > 1 ? arguments[1] : undefined;
+ switch (action.type) {
+ case _action_type.STATUS.TOGGLEBTNSUBMIT:
+ return Object.assign({}, state, {
+ btnSubmit: false
+ } // !state.btnSubmit
+ );
+ case _action_type.STATUS.TOGGLEBTNALL:
+ return Object.assign({}, state, {
+ btnSubmit: false
+ } // !state.btnSubmit
+ );
+ case _action_type.STATUS.ENABLEBTNALL:
+ case _action_type.EDITPEAK.ADDPOSITIVE:
+ case _action_type.EDITPEAK.RMPOSITIVE:
+ case _action_type.EDITPEAK.ADDNEGATIVE:
+ case _action_type.EDITPEAK.RMNEGATIVE:
+ case _action_type.THRESHOLD.UPDATE_VALUE:
+ case _action_type.THRESHOLD.RESET_VALUE:
+ return Object.assign({}, state, {
+ btnSubmit: false
+ });
+ case _action_type.LAYOUT.UPDATE:
+ return Object.assign({}, state, {
+ btnSubmit: false
+ });
+ case _action_type.MANAGER.RESETALL:
+ return initialState;
+ default:
+ return initialState;
+ }
+};
+var _default = exports.default = statusReducer;
\ No newline at end of file
diff --git a/dist/reducers/reducer_submit.js b/dist/reducers/reducer_submit.js
new file mode 100644
index 00000000..35dd2024
--- /dev/null
+++ b/dist/reducers/reducer_submit.js
@@ -0,0 +1,61 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+var _action_type = require("../constants/action_type");
+var _format = _interopRequireDefault(require("../helpers/format"));
+/* eslint-disable prefer-object-spread, default-param-last */
+
+const initialState = {
+ isAscend: false,
+ isIntensity: true,
+ decimal: 2,
+ operation: {
+ name: 'empty'
+ }
+};
+const updateOperation = action => ({
+ operation: action.payload || initialState.operation
+});
+const submitReducer = function submitReducer() {
+ let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+ let action = arguments.length > 1 ? arguments[1] : undefined;
+ switch (action.type) {
+ case _action_type.SUBMIT.TOGGLE_IS_ASCEND:
+ return Object.assign({}, state, {
+ isAscend: !state.isAscend
+ });
+ case _action_type.SUBMIT.TOGGLE_IS_INTENSITY:
+ return Object.assign({}, state, {
+ isIntensity: !state.isIntensity
+ });
+ case _action_type.SUBMIT.UPDATE_OPERATION:
+ return Object.assign({}, state, updateOperation(action));
+ case _action_type.SUBMIT.UPDATE_DECIMAL:
+ return Object.assign({}, state, {
+ decimal: action.payload.target.value
+ });
+ case _action_type.LAYOUT.UPDATE:
+ {
+ const decimal = _format.default.spectraDigit(action.payload);
+ return Object.assign({}, state, {
+ decimal
+ });
+ }
+ case _action_type.MANAGER.RESETALL:
+ {
+ const decimal = _format.default.spectraDigit(action.payload.operation.layout);
+ return Object.assign({}, state, {
+ decimal,
+ isIntensity: true,
+ isAscend: false
+ });
+ }
+ default:
+ return state;
+ }
+};
+var _default = exports.default = submitReducer;
\ No newline at end of file
diff --git a/dist/reducers/reducer_threshold.js b/dist/reducers/reducer_threshold.js
new file mode 100644
index 00000000..3b35ae34
--- /dev/null
+++ b/dist/reducers/reducer_threshold.js
@@ -0,0 +1,224 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+var _action_type = require("../constants/action_type");
+/* eslint-disable prefer-object-spread, default-param-last */
+
+const initialState = {
+ selectedIdx: 0,
+ list: [{
+ isEdit: true,
+ value: false,
+ upper: false,
+ lower: false
+ }]
+};
+
+// const defaultThresHold = {
+// isEdit: true,
+// value: false,
+// upper: false,
+// lower: false,
+// };
+
+const setThresHoldValue = (state, action) => {
+ const {
+ payload
+ } = action;
+ const {
+ list,
+ selectedIdx
+ } = state;
+ if (payload) {
+ const {
+ value,
+ curveIdx
+ } = payload;
+ const selectedThres = list[curveIdx];
+ const newSelectedThres = Object.assign({}, selectedThres, {
+ value
+ });
+ const newListThres = [...list];
+ newListThres[curveIdx] = newSelectedThres;
+ return Object.assign({}, state, {
+ list: newListThres,
+ selectedIdx: curveIdx
+ });
+ }
+ const selectedThres = list[selectedIdx];
+ const newSelectedThres = Object.assign({}, selectedThres, {
+ value: payload
+ });
+ const newListThres = [...list];
+ newListThres[selectedIdx] = newSelectedThres;
+ return Object.assign({}, state, {
+ list: newListThres
+ });
+};
+const setThresHoldUpper = (state, action) => {
+ const {
+ payload
+ } = action;
+ const {
+ list,
+ selectedIdx
+ } = state;
+ if (payload) {
+ const {
+ value,
+ curveIdx
+ } = payload;
+ const selectedThres = list[curveIdx];
+ const newSelectedThres = Object.assign({}, selectedThres, {
+ upper: value
+ });
+ const newListThres = [...list];
+ newListThres[curveIdx] = newSelectedThres;
+ return Object.assign({}, state, {
+ list: newListThres,
+ selectedIdx: curveIdx
+ });
+ }
+ const selectedThres = list[selectedIdx];
+ const newSelectedThres = Object.assign({}, selectedThres, {
+ upper: payload
+ });
+ const newListThres = [...list];
+ newListThres[selectedIdx] = newSelectedThres;
+ return Object.assign({}, state, {
+ list: newListThres
+ });
+};
+const setThresHoldLower = (state, action) => {
+ const {
+ payload
+ } = action;
+ const {
+ list,
+ selectedIdx
+ } = state;
+ if (payload) {
+ const {
+ value,
+ curveIdx
+ } = payload;
+ const selectedThres = list[curveIdx];
+ const newSelectedThres = Object.assign({}, selectedThres, {
+ lower: value
+ });
+ const newListThres = [...list];
+ newListThres[curveIdx] = newSelectedThres;
+ return Object.assign({}, state, {
+ list: newListThres,
+ selectedIdx: curveIdx
+ });
+ }
+ const selectedThres = list[selectedIdx];
+ const newSelectedThres = Object.assign({}, selectedThres, {
+ lower: payload
+ });
+ const newListThres = [...list];
+ newListThres[selectedIdx] = newSelectedThres;
+ return Object.assign({}, state, {
+ list: newListThres
+ });
+};
+const setThresHoldIsEdit = state => {
+ const {
+ list,
+ selectedIdx
+ } = state;
+ const selectedThres = list[selectedIdx];
+ const {
+ isEdit
+ } = selectedThres;
+ const newSelectedThres = Object.assign({}, selectedThres, {
+ isEdit: !isEdit
+ });
+ const newListThres = [...list];
+ newListThres[selectedIdx] = newSelectedThres;
+ return Object.assign({}, state, {
+ list: newListThres
+ });
+};
+const resetAll = (state, action) => {
+ const {
+ payload
+ } = action;
+ const {
+ list
+ } = state;
+ const newList = list.map(item => ({
+ isEdit: item.isEdit,
+ value: payload && payload.thresRef,
+ upper: item.upper,
+ lower: item.lower
+ }));
+ return Object.assign({}, state, {
+ selectedIdx: 0,
+ list: newList
+ });
+};
+const setListThreshold = (state, action) => {
+ const {
+ payload
+ } = action;
+ const {
+ list
+ } = state;
+ if (payload && payload.length > list.length) {
+ const newList = payload.map(() => ({
+ isEdit: true,
+ value: false,
+ upper: false,
+ lower: false
+ }));
+ return Object.assign({}, state, {
+ list: newList
+ });
+ }
+ return state;
+};
+const resetInitCommon = state => {
+ const {
+ list
+ } = state;
+ const newList = list.map(item => ({
+ isEdit: true,
+ value: item.value,
+ upper: item.upper,
+ lower: item.lower
+ }));
+ return Object.assign({}, state, {
+ selectedIdx: 0,
+ list: newList
+ });
+};
+const thresholdReducer = function thresholdReducer() {
+ let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+ let action = arguments.length > 1 ? arguments[1] : undefined;
+ switch (action.type) {
+ case _action_type.CURVE.SET_ALL_CURVES:
+ return setListThreshold(state, action);
+ case _action_type.THRESHOLD.UPDATE_VALUE:
+ return setThresHoldValue(state, action);
+ case _action_type.THRESHOLD.UPDATE_UPPER_VALUE:
+ return setThresHoldUpper(state, action);
+ case _action_type.THRESHOLD.UPDATE_LOWER_VALUE:
+ return setThresHoldLower(state, action);
+ case _action_type.THRESHOLD.RESET_VALUE:
+ return setThresHoldValue(state, action);
+ case _action_type.THRESHOLD.TOGGLE_ISEDIT:
+ return setThresHoldIsEdit(state);
+ case _action_type.MANAGER.RESET_INIT_COMMON:
+ return resetInitCommon(state);
+ case _action_type.MANAGER.RESETALL:
+ return resetAll(state, action);
+ default:
+ return state;
+ }
+};
+var _default = exports.default = thresholdReducer;
\ No newline at end of file
diff --git a/dist/reducers/reducer_ui.js b/dist/reducers/reducer_ui.js
new file mode 100644
index 00000000..206b8212
--- /dev/null
+++ b/dist/reducers/reducer_ui.js
@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+var _action_type = require("../constants/action_type");
+var _list_ui = require("../constants/list_ui");
+/* eslint-disable prefer-object-spread, default-param-last */
+
+const initialState = {
+ viewer: _list_ui.LIST_UI_VIEWER_TYPE.SPECTRUM,
+ sweepType: _list_ui.LIST_UI_SWEEP_TYPE.ZOOMIN,
+ sweepExtent: {
+ xExtent: false,
+ yExtent: false
+ },
+ jcampIdx: 0
+};
+const uiReducer = function uiReducer() {
+ let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+ let action = arguments.length > 1 ? arguments[1] : undefined;
+ switch (action.type) {
+ case _action_type.UI.VIEWER.SET_TYPE:
+ return Object.assign({}, state, {
+ viewer: action.payload
+ });
+ case _action_type.UI.SWEEP.SET_TYPE:
+ if (action.payload === _list_ui.LIST_UI_SWEEP_TYPE.ZOOMRESET) {
+ return Object.assign({}, state, {
+ sweepExtent: {
+ xExtent: false,
+ yExtent: false
+ }
+ });
+ }
+ return Object.assign({}, state, {
+ sweepType: action.payload,
+ jcampIdx: action.jcampIdx
+ });
+ case _action_type.UI.SWEEP.SELECT_ZOOMIN:
+ return Object.assign({}, state, {
+ sweepExtent: action.payload
+ });
+ case _action_type.MANAGER.RESETALL:
+ return initialState;
+ default:
+ return state;
+ }
+};
+var _default = exports.default = uiReducer;
\ No newline at end of file
diff --git a/dist/reducers/reducer_voltammetry.js b/dist/reducers/reducer_voltammetry.js
new file mode 100644
index 00000000..3bc1f83c
--- /dev/null
+++ b/dist/reducers/reducer_voltammetry.js
@@ -0,0 +1,574 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+var _action_type = require("../constants/action_type");
+var _chem = require("../helpers/chem");
+/* eslint-disable prefer-object-spread, default-param-last */
+
+const initialState = {
+ spectraList: []
+};
+const initSpectra = {
+ list: [],
+ origin: [],
+ selectedIdx: -1,
+ isWorkMaxPeak: true,
+ jcampIdx: -1,
+ shift: {
+ ref: null,
+ val: 0,
+ prevValue: 0
+ },
+ hasRefPeak: false,
+ history: []
+};
+const addPairPeak = (state, action) => {
+ const {
+ payload
+ } = action;
+ const {
+ spectraList
+ } = state;
+ if (payload !== undefined) {
+ let spectra = spectraList[payload];
+ if (!spectra) {
+ spectra = initSpectra;
+ spectraList.push(spectra);
+ }
+ const {
+ list,
+ selectedIdx
+ } = spectra;
+ let index = selectedIdx;
+ index += 1;
+ const newList = list.map(item => {
+ // eslint-disable-line
+ return {
+ ...item
+ };
+ });
+ newList.push({
+ min: null,
+ max: null,
+ isRef: false,
+ e12: null,
+ createdAt: Date.now()
+ });
+ spectraList[payload] = Object.assign({}, spectra, {
+ list: newList,
+ selectedIdx: index,
+ origin: [...newList]
+ }); // eslint-disable-line
+ return Object.assign({}, state, {
+ spectraList
+ });
+ }
+ return state;
+};
+const removePairPeak = (state, action) => {
+ const {
+ payload
+ } = action;
+ const {
+ spectraList
+ } = state;
+ if (payload !== undefined) {
+ const {
+ index,
+ jcampIdx
+ } = payload;
+ const spectra = spectraList[jcampIdx];
+ if (spectra) {
+ const {
+ list,
+ origin
+ } = spectra;
+ list.splice(index, 1);
+ origin.splice(index, 1);
+ spectraList[jcampIdx] = Object.assign({}, spectra, {
+ list,
+ selectedIdx: index,
+ origin
+ });
+ return Object.assign({}, state, {
+ spectraList
+ });
+ }
+ return state;
+ }
+ return state;
+};
+const getE12 = data => {
+ if (data.max && data.min) {
+ const {
+ max,
+ min
+ } = data;
+ const delta = (0, _chem.GetCyclicVoltaPeakSeparate)(max.x, min.x);
+ return Math.min(max.x, min.x) + 0.5 * delta;
+ }
+ return null;
+};
+const addPeak = function addPeak(state, action) {
+ let isMax = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+ const {
+ payload
+ } = action;
+ const {
+ spectraList
+ } = state;
+ if (payload) {
+ const {
+ peak,
+ index,
+ jcampIdx
+ } = payload;
+ const spectra = spectraList[jcampIdx];
+ const {
+ list
+ } = spectra;
+ const newList = list.map(item => {
+ // eslint-disable-line
+ return {
+ ...item
+ };
+ });
+ let pairPeak = newList[index];
+ if (isMax) {
+ pairPeak = Object.assign({}, pairPeak, {
+ max: peak
+ });
+ } else {
+ pairPeak = Object.assign({}, pairPeak, {
+ min: peak
+ });
+ }
+ pairPeak.e12 = getE12(pairPeak);
+ pairPeak.updatedAt = Date.now();
+ newList[index] = pairPeak;
+ spectraList[jcampIdx] = Object.assign({}, spectra, {
+ list: newList,
+ selectedIdx: index,
+ jcampIdx,
+ origin: [...newList]
+ });
+ return Object.assign({}, state, {
+ spectraList
+ });
+ }
+ return state;
+};
+const removePeak = function removePeak(state, action) {
+ let isMax = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+ const {
+ payload
+ } = action;
+ const {
+ spectraList
+ } = state;
+ if (payload) {
+ const {
+ index,
+ jcampIdx
+ } = payload;
+ const spectra = spectraList[jcampIdx];
+ const {
+ list
+ } = spectra;
+ const newList = list;
+ const pairPeak = newList[index];
+ if (isMax) {
+ pairPeak.max = null;
+ } else {
+ pairPeak.min = null;
+ }
+ pairPeak.e12 = getE12(pairPeak);
+ pairPeak.updatedAt = Date.now();
+ newList[index] = pairPeak;
+ spectraList[jcampIdx] = Object.assign({}, spectra, {
+ list: newList,
+ selectedIdx: index,
+ jcampIdx,
+ origin: [...newList]
+ });
+ return Object.assign({}, state, {
+ spectraList
+ });
+ }
+ return state;
+};
+const selectPairPeak = (state, action) => {
+ const {
+ payload
+ } = action;
+ if (payload !== undefined) {
+ const {
+ spectraList
+ } = state;
+ const {
+ index,
+ jcampIdx
+ } = payload;
+ const spectra = spectraList[jcampIdx];
+ if (spectra) {
+ spectraList[jcampIdx] = Object.assign({}, spectra, {
+ selectedIdx: index
+ });
+ return Object.assign({}, state, {
+ spectraList
+ });
+ }
+ return state;
+ }
+ return state;
+};
+const setWorkWithMaxPeak = (state, action) => {
+ const {
+ payload
+ } = action;
+ if (payload !== undefined) {
+ const {
+ spectraList
+ } = state;
+ const {
+ isMax,
+ jcampIdx
+ } = payload;
+ const spectra = spectraList[jcampIdx];
+ if (spectra) {
+ spectraList[jcampIdx] = Object.assign({}, spectra, {
+ isWorkMaxPeak: isMax
+ });
+ return Object.assign({}, state, {
+ spectraList
+ });
+ }
+ return state;
+ }
+ return state;
+};
+const addPecker = (state, action) => {
+ const {
+ payload
+ } = action;
+ const {
+ spectraList
+ } = state;
+ if (payload) {
+ const {
+ peak,
+ index,
+ jcampIdx
+ } = payload;
+ const spectra = spectraList[jcampIdx];
+ const {
+ list
+ } = spectra;
+ const newList = list;
+ const pairPeak = newList[index];
+ pairPeak.pecker = peak;
+ pairPeak.updatedAt = Date.now();
+ newList[index] = pairPeak;
+ spectraList[jcampIdx] = Object.assign({}, spectra, {
+ list: newList,
+ selectedIdx: index,
+ jcampIdx,
+ origin: [...newList]
+ });
+ return Object.assign({}, state, {
+ spectraList
+ });
+ }
+ return state;
+};
+const removePecker = (state, action) => {
+ const {
+ payload
+ } = action;
+ const {
+ spectraList
+ } = state;
+ if (payload) {
+ const {
+ index,
+ jcampIdx
+ } = payload;
+ const spectra = spectraList[jcampIdx];
+ const {
+ list
+ } = spectra;
+ const newList = list;
+ const pairPeak = newList[index];
+ pairPeak.pecker = null;
+ pairPeak.updatedAt = Date.now();
+ newList[index] = pairPeak;
+ spectraList[jcampIdx] = Object.assign({}, spectra, {
+ list: newList,
+ selectedIdx: index,
+ jcampIdx,
+ origin: [...newList]
+ });
+ return Object.assign({}, state, {
+ spectraList
+ });
+ }
+ return state;
+};
+const setRef = (state, action) => {
+ const {
+ payload
+ } = action;
+ const {
+ spectraList
+ } = state;
+ if (payload) {
+ const {
+ jcampIdx
+ } = payload;
+ const spectra = spectraList[jcampIdx];
+ const {
+ list,
+ shift,
+ hasRefPeak,
+ history
+ } = spectra;
+ const newShift = Object.assign({}, shift);
+ const refPeaks = list.filter(pairPeak => pairPeak.isRef === true);
+ let offset = 0.0;
+ if (hasRefPeak) {
+ const currRefPeaks = refPeaks[0];
+ newShift.ref = currRefPeaks;
+ const {
+ val
+ } = shift;
+ const {
+ e12
+ } = currRefPeaks;
+ offset = e12 - val;
+ const newList = spectra.list.map(pairPeak => {
+ //eslint-disable-line
+ const {
+ max,
+ min,
+ pecker,
+ isRef
+ } = pairPeak;
+ let newMax = null;
+ let newMin = null;
+ let newPecker = null;
+ if (max) {
+ newMax = hasRefPeak ? {
+ x: max.x - offset,
+ y: max.y
+ } : {
+ x: max.x + parseFloat(offset),
+ y: max.y
+ };
+ }
+ if (min) {
+ newMin = hasRefPeak ? {
+ x: min.x - offset,
+ y: min.y
+ } : {
+ x: min.x + parseFloat(offset),
+ y: min.y
+ };
+ }
+ if (pecker) {
+ newPecker = hasRefPeak ? {
+ x: pecker.x - offset,
+ y: pecker.y
+ } : {
+ x: pecker.x + parseFloat(offset),
+ y: pecker.y
+ }; //eslint-disable-line
+ }
+ const newPairPeak = Object.assign({}, pairPeak, {
+ max: newMax,
+ min: newMin,
+ pecker: newPecker
+ }); //eslint-disable-line
+ newPairPeak.e12 = getE12(newPairPeak);
+ newPairPeak.updatedAt = Date.now();
+ if (isRef) {
+ newShift.ref = newPairPeak;
+ newShift.prevValue += offset;
+ }
+ return newPairPeak;
+ });
+ history.push(...[newList]);
+ spectra.list = newList;
+ } else {
+ newShift.ref = null;
+ const {
+ val
+ } = newShift;
+ offset = val;
+ const newList = spectra.origin.map(pairPeak => {
+ //eslint-disable-line
+ const {
+ max,
+ min,
+ pecker
+ } = pairPeak;
+ let newMax = null;
+ let newMin = null;
+ let newPecker = null;
+ if (max) {
+ newMax = {
+ x: max.x + parseFloat(val),
+ y: max.y
+ };
+ }
+ if (min) {
+ newMin = {
+ x: min.x + parseFloat(val),
+ y: min.y
+ };
+ }
+ if (pecker) {
+ newPecker = {
+ x: pecker.x + parseFloat(val),
+ y: pecker.y
+ };
+ }
+ const newPairPeak = Object.assign({}, pairPeak, {
+ max: newMax,
+ min: newMin,
+ pecker: newPecker,
+ isRef: false
+ }); //eslint-disable-line
+ newPairPeak.e12 = getE12(newPairPeak);
+ newPairPeak.updatedAt = Date.now();
+ return newPairPeak;
+ });
+ history.push(...[newList]);
+ spectra.list = newList;
+ newShift.prevValue = parseFloat(offset);
+ }
+ spectraList[jcampIdx] = Object.assign({}, spectra, {
+ shift: newShift,
+ jcampIdx
+ });
+ return Object.assign({}, state, {
+ spectraList
+ });
+ }
+ return state;
+};
+const selectRefPeaks = (state, action) => {
+ const {
+ payload
+ } = action;
+ const {
+ spectraList
+ } = state;
+ if (payload) {
+ const {
+ index,
+ jcampIdx,
+ checked
+ } = payload;
+ const spectra = spectraList[jcampIdx];
+ const {
+ list,
+ shift,
+ history
+ } = spectra;
+ const newShift = shift;
+ const newList = list;
+ newList.forEach((pairPeak, idx) => {
+ const newPairPeak = pairPeak;
+ newPairPeak.isRef = false;
+ newPairPeak.updatedAt = Date.now();
+ if (idx === index) {
+ newPairPeak.isRef = checked;
+ newList[index] = newPairPeak;
+ }
+ });
+ const refPeaks = newList.filter(pairPeak => pairPeak.isRef === true);
+ const hasRefPeak = refPeaks.length > 0;
+ history.push(...[newList]);
+ spectraList[jcampIdx] = Object.assign({}, spectra, {
+ list: newList,
+ selectedIdx: index,
+ jcampIdx,
+ hasRefPeak,
+ shift: newShift
+ });
+ return Object.assign({}, state, {
+ spectraList
+ });
+ }
+ return state;
+};
+const selectRefFactor = (state, action) => {
+ const {
+ payload
+ } = action;
+ const {
+ spectraList
+ } = state;
+ if (payload) {
+ const {
+ factor,
+ curveIdx
+ } = payload;
+ const spectra = spectraList[curveIdx];
+ const {
+ shift
+ } = spectra;
+ const newShift = Object.assign({}, shift);
+ newShift.val = factor;
+ spectraList[curveIdx] = Object.assign({}, spectra, {
+ shift: newShift,
+ jcampIdx: curveIdx
+ });
+ return Object.assign({}, state, {
+ spectraList
+ });
+ }
+ return state;
+};
+const cyclicVoltaReducer = function cyclicVoltaReducer() {
+ let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+ let action = arguments.length > 1 ? arguments[1] : undefined;
+ switch (action.type) {
+ case _action_type.CYCLIC_VOLTA_METRY.ADD_PAIR_PEAKS:
+ return addPairPeak(state, action);
+ case _action_type.CYCLIC_VOLTA_METRY.REMOVE_PAIR_PEAKS:
+ return removePairPeak(state, action);
+ case _action_type.CYCLIC_VOLTA_METRY.ADD_MAX_PEAK:
+ return addPeak(state, action);
+ case _action_type.CYCLIC_VOLTA_METRY.REMOVE_MAX_PEAK:
+ return removePeak(state, action);
+ case _action_type.CYCLIC_VOLTA_METRY.ADD_MIN_PEAK:
+ return addPeak(state, action, false);
+ case _action_type.CYCLIC_VOLTA_METRY.REMOVE_MIN_PEAK:
+ return removePeak(state, action, false);
+ case _action_type.CYCLIC_VOLTA_METRY.WORK_WITH_MAX_PEAK:
+ return setWorkWithMaxPeak(state, action);
+ case _action_type.CYCLIC_VOLTA_METRY.SELECT_PAIR_PEAK:
+ return selectPairPeak(state, action);
+ case _action_type.CYCLIC_VOLTA_METRY.ADD_PECKER:
+ return addPecker(state, action);
+ case _action_type.CYCLIC_VOLTA_METRY.REMOVE_PECKER:
+ return removePecker(state, action);
+ case _action_type.CYCLIC_VOLTA_METRY.SET_REF:
+ return setRef(state, action);
+ case _action_type.CYCLIC_VOLTA_METRY.SELECT_REF_PEAK:
+ return selectRefPeaks(state, action);
+ case _action_type.CYCLIC_VOLTA_METRY.SET_FACTOR:
+ return selectRefFactor(state, action);
+ case _action_type.CYCLIC_VOLTA_METRY.RESETALL:
+ return Object.assign({}, state, {
+ spectraList: []
+ });
+ default:
+ return state;
+ }
+};
+var _default = exports.default = cyclicVoltaReducer;
\ No newline at end of file
diff --git a/dist/reducers/reducer_wavelength.js b/dist/reducers/reducer_wavelength.js
new file mode 100644
index 00000000..8c3dfea9
--- /dev/null
+++ b/dist/reducers/reducer_wavelength.js
@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+var _list_wavelength = require("../constants/list_wavelength");
+var _action_type = require("../constants/action_type");
+/* eslint-disable default-param-last */
+
+const initialState = _list_wavelength.LIST_WAVE_LENGTH[0];
+const wavelengthReducer = function wavelengthReducer() {
+ let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+ let action = arguments.length > 1 ? arguments[1] : undefined;
+ switch (action.type) {
+ case _action_type.XRD.UPDATE_WAVE_LENGTH:
+ return action.payload;
+ default:
+ return state;
+ }
+};
+var _default = exports.default = wavelengthReducer;
\ No newline at end of file
diff --git a/dist/reducers/undo_redo_config.js b/dist/reducers/undo_redo_config.js
new file mode 100644
index 00000000..7a8cfeaa
--- /dev/null
+++ b/dist/reducers/undo_redo_config.js
@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.undoRedoConfig = exports.undoRedoActions = void 0;
+var _reduxUndo = require("redux-undo");
+var _action_type = require("../constants/action_type");
+const undoRedoActions = exports.undoRedoActions = [_action_type.EDITPEAK.ADD_POSITIVE, _action_type.EDITPEAK.ADD_NEGATIVE, _action_type.EDITPEAK.RM_POSITIVE, _action_type.EDITPEAK.RM_NEGATIVE, _action_type.EDITPEAK.SHIFT, _action_type.EDITPEAK.CLEAR_ALL, _action_type.MANAGER.RESETALL, _action_type.MANAGER.RESETSHIFT, _action_type.MANAGER.RESET_INIT_COMMON, _action_type.MANAGER.RESET_INIT_NMR, _action_type.MANAGER.RESET_INIT_MS, _action_type.MANAGER.RESET_INIT_COMMON_WITH_INTERGATION, _action_type.UI.SWEEP.SELECT_INTEGRATION, _action_type.UI.SWEEP.SELECT_MULTIPLICITY_RDC, _action_type.INTEGRATION.RM_ONE, _action_type.INTEGRATION.SET_REF, _action_type.INTEGRATION.SET_FKR, _action_type.INTEGRATION.RESET_ALL, _action_type.INTEGRATION.CLEAR_ALL, _action_type.MULTIPLICITY.PEAK_RM_BY_PANEL_RDC, _action_type.MULTIPLICITY.PEAK_RM_BY_UI_RDC, _action_type.MULTIPLICITY.PEAK_ADD_BY_UI_RDC, _action_type.MULTIPLICITY.RESET_ONE_RDC, _action_type.MULTIPLICITY.UPDATE_J, _action_type.MULTIPLICITY.TYPE_SELECT_RDC, _action_type.MULTIPLICITY.ONE_CLICK, _action_type.MULTIPLICITY.ONE_CLICK_BY_UI, _action_type.MULTIPLICITY.RESET_ALL_RDC, _action_type.MULTIPLICITY.CLEAR_ALL];
+const undoRedoConfig = exports.undoRedoConfig = {
+ debug: false,
+ limit: 10,
+ ignoreInitialState: true,
+ filter: (0, _reduxUndo.includeAction)(undoRedoActions),
+ clearHistoryType: [_action_type.EDITPEAK.SHIFT, _action_type.EDITPEAK.CLEAR_ALL, _action_type.MANAGER.RESETALL, _action_type.MANAGER.RESETSHIFT, _action_type.MANAGER.RESET_INIT_COMMON, _action_type.MANAGER.RESET_INIT_NMR, _action_type.MANAGER.RESET_INIT_MS, _action_type.MANAGER.RESET_INIT_COMMON_WITH_INTERGATION],
+ neverSkipReducer: [_action_type.EDITPEAK.SHIFT, _action_type.EDITPEAK.CLEAR_ALL, _action_type.MANAGER.RESETALL, _action_type.MANAGER.RESETSHIFT, _action_type.MANAGER.RESET_INIT_COMMON, _action_type.MANAGER.RESET_INIT_NMR, _action_type.MANAGER.RESET_INIT_MS, _action_type.MANAGER.RESET_INIT_COMMON_WITH_INTERGATION]
+};
\ No newline at end of file
diff --git a/dist/sagas/index.js b/dist/sagas/index.js
new file mode 100644
index 00000000..6b9c1884
--- /dev/null
+++ b/dist/sagas/index.js
@@ -0,0 +1,17 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = rootSaga;
+var _effects = require("redux-saga/effects");
+var _saga_edit_peak = _interopRequireDefault(require("./saga_edit_peak"));
+var _saga_manager = _interopRequireDefault(require("./saga_manager"));
+var _saga_ui = _interopRequireDefault(require("./saga_ui"));
+var _saga_meta = _interopRequireDefault(require("./saga_meta"));
+var _saga_multiplicity = _interopRequireDefault(require("./saga_multiplicity"));
+var _saga_multi_entities = _interopRequireDefault(require("./saga_multi_entities"));
+function* rootSaga() {
+ yield (0, _effects.all)([..._saga_edit_peak.default, ..._saga_manager.default, ..._saga_ui.default, ..._saga_meta.default, ..._saga_multiplicity.default, ..._saga_multi_entities.default]);
+}
\ No newline at end of file
diff --git a/dist/sagas/saga_edit_peak.js b/dist/sagas/saga_edit_peak.js
new file mode 100644
index 00000000..a68ad59d
--- /dev/null
+++ b/dist/sagas/saga_edit_peak.js
@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+var _effects = require("redux-saga/effects");
+var _action_type = require("../constants/action_type");
+var _shift = require("../helpers/shift");
+var _list_shift = require("../constants/list_shift");
+const getShift = state => state.shift;
+const getEditPeak = state => state.editPeak.present;
+function* addVirtualFactor(action) {
+ const originShift = yield (0, _effects.select)(getShift);
+ const origEPeak = yield (0, _effects.select)(getEditPeak);
+ const {
+ payload
+ } = action;
+ const {
+ curveIdx
+ } = payload;
+ const {
+ peaks
+ } = origEPeak;
+ let currentOriginPeaks = peaks[curveIdx];
+ if (currentOriginPeaks === false || currentOriginPeaks === undefined) {
+ currentOriginPeaks = {
+ prevOffset: 0,
+ pos: [],
+ neg: []
+ };
+ }
+ let currentOriginShift = originShift.shifts[curveIdx];
+ if (currentOriginShift === false || currentOriginShift === undefined) {
+ const shiftNone = _list_shift.LIST_SHIFT_1H[0];
+ currentOriginShift = {
+ ref: shiftNone,
+ peak: false,
+ enable: true
+ };
+ }
+ const origRef = currentOriginShift.ref;
+ const origApex = currentOriginShift.peak;
+ const {
+ prevOffset,
+ pos,
+ neg
+ } = currentOriginPeaks;
+ const absOffset = (0, _shift.FromManualToOffset)(origRef, origApex);
+ const relOffset = prevOffset - absOffset;
+ const nextPos = (0, _shift.VirtalPts)(pos, relOffset);
+ const nextNeg = (0, _shift.VirtalPts)(neg, relOffset);
+ yield (0, _effects.put)({
+ type: _action_type.EDITPEAK.SHIFT,
+ payload: Object.assign({}, payload, {
+ // eslint-disable-line
+ prevOffset: absOffset,
+ pos: nextPos,
+ neg: nextNeg
+ })
+ });
+}
+const editPeakSagas = [(0, _effects.takeEvery)(_action_type.SHIFT.SET_REF, addVirtualFactor), (0, _effects.takeEvery)(_action_type.SHIFT.SET_PEAK, addVirtualFactor)];
+var _default = exports.default = editPeakSagas;
+/* LOGIC
+ -no po - tg
+ | picked | another | absoffset | prevOffset | relative | newOffset
+-------------------------------------------------------------------
+0 | 40 20 - - - 0
+1 | 180 160 -140 0 140 140
+2 | 80 60 -40 -140 -100 100
+3 | 20 0 +20 -100 -120
+-------------------------------------------------------------------
+
+*/
\ No newline at end of file
diff --git a/dist/sagas/saga_manager.js b/dist/sagas/saga_manager.js
new file mode 100644
index 00000000..e87aec57
--- /dev/null
+++ b/dist/sagas/saga_manager.js
@@ -0,0 +1,97 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+var _effects = require("redux-saga/effects");
+var _action_type = require("../constants/action_type");
+const getLayout = state => state.layout;
+const getCurveSt = state => state.curve;
+const getIntegrationSt = state => state.integration.present;
+function* resetShift(action) {
+ const curveSt = yield (0, _effects.select)(getCurveSt);
+ const layout = yield (0, _effects.select)(getLayout);
+ const {
+ payload
+ } = action;
+ const {
+ curveIdx,
+ listCurves
+ } = curveSt;
+ const numberOfCurve = listCurves.length;
+ yield (0, _effects.put)({
+ type: _action_type.MANAGER.RESETSHIFT,
+ payload: Object.assign(
+ // eslint-disable-line
+ {}, payload, {
+ layout,
+ curvesInfo: {
+ isMultiCurve: numberOfCurve > 0,
+ curveIdx,
+ numberOfCurve
+ }
+ })
+ });
+}
+function* resetInitNmr(action) {
+ const curveSt = yield (0, _effects.select)(getCurveSt);
+ const integationSt = yield (0, _effects.select)(getIntegrationSt);
+ const {
+ curveIdx
+ } = curveSt;
+ const {
+ integration,
+ simulation
+ } = action.payload;
+ const {
+ integrations
+ } = integationSt;
+ const newArrIntegration = [...integrations];
+ newArrIntegration[curveIdx] = integration;
+ const payload = Object.assign({}, integationSt, {
+ integrations: newArrIntegration,
+ selectedIdx: curveIdx
+ }); // eslint-disable-line
+
+ if (integration) {
+ yield (0, _effects.put)({
+ type: _action_type.INTEGRATION.RESET_ALL_RDC,
+ payload
+ });
+ }
+ if (simulation) {
+ yield (0, _effects.put)({
+ type: _action_type.SIMULATION.RESET_ALL_RDC,
+ payload: simulation
+ });
+ }
+}
+function* resetInitCommonWithIntergation(action) {
+ const curveSt = yield (0, _effects.select)(getCurveSt);
+ const integationSt = yield (0, _effects.select)(getIntegrationSt);
+ const {
+ curveIdx
+ } = curveSt;
+ const {
+ integration
+ } = action.payload;
+ const {
+ integrations
+ } = integationSt;
+ const newArrIntegration = [...integrations];
+ newArrIntegration[curveIdx] = integration;
+ const payload = Object.assign({}, integationSt, {
+ integrations: newArrIntegration,
+ selectedIdx: curveIdx
+ }); // eslint-disable-line
+
+ if (integration) {
+ yield (0, _effects.put)({
+ type: _action_type.INTEGRATION.RESET_ALL_RDC,
+ payload
+ });
+ }
+}
+const managerSagas = [(0, _effects.takeEvery)(_action_type.MANAGER.RESETALL, resetShift), (0, _effects.takeEvery)(_action_type.MANAGER.RESET_INIT_NMR, resetInitNmr), (0, _effects.takeEvery)(_action_type.MANAGER.RESET_INIT_COMMON_WITH_INTERGATION, resetInitCommonWithIntergation)];
+var _default = exports.default = managerSagas;
\ No newline at end of file
diff --git a/dist/sagas/saga_meta.js b/dist/sagas/saga_meta.js
new file mode 100644
index 00000000..6b3be549
--- /dev/null
+++ b/dist/sagas/saga_meta.js
@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+var _effects = require("redux-saga/effects");
+var _action_type = require("../constants/action_type");
+var _peakInterval = require("../third_party/peakInterval");
+function* updateMetaPeaks(action) {
+ const {
+ payload
+ } = action;
+ const {
+ intervalL,
+ intervalR
+ } = (0, _peakInterval.getPeakIntervals)(payload);
+ const {
+ observeFrequency,
+ data
+ } = payload.spectra[0];
+ const deltaX = Math.abs(data[0].x[0] - data[0].x[1]);
+ yield (0, _effects.put)({
+ type: _action_type.META.UPDATE_PEAKS_RDC,
+ payload: {
+ peaks: {
+ intervalL,
+ intervalR,
+ observeFrequency,
+ deltaX
+ }
+ }
+ });
+}
+function* updateMetaData(action) {
+ yield (0, _effects.put)({
+ type: _action_type.META.UPDATE_META_DATA_RDC,
+ payload: {
+ dscMetaData: action.payload
+ }
+ });
+}
+const metaSagas = [(0, _effects.takeEvery)(_action_type.META.UPDATE_PEAKS, updateMetaPeaks), (0, _effects.takeEvery)(_action_type.META.UPDATE_META_DATA, updateMetaData)];
+var _default = exports.default = metaSagas;
\ No newline at end of file
diff --git a/dist/sagas/saga_multi_entities.js b/dist/sagas/saga_multi_entities.js
new file mode 100644
index 00000000..b32e30a8
--- /dev/null
+++ b/dist/sagas/saga_multi_entities.js
@@ -0,0 +1,202 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+var _effects = require("redux-saga/effects");
+var _action_type = require("../constants/action_type");
+var _list_layout = require("../constants/list_layout");
+var _format = _interopRequireDefault(require("../helpers/format"));
+/* eslint-disable no-plusplus */
+
+const getLayoutSt = state => state.layout;
+const getCurveSt = state => state.curve;
+const getIntegrationSt = state => state.integration.present;
+const getMultiplicitySt = state => state.multiplicity.present;
+function getMaxMinPeak(curve) {
+ return curve.maxminPeak;
+}
+function* setCyclicVoltametry(action) {
+ // eslint-disable-line
+ const curveSt = yield (0, _effects.select)(getCurveSt);
+ const {
+ listCurves
+ } = curveSt;
+ if (listCurves) {
+ yield (0, _effects.put)({
+ type: _action_type.CYCLIC_VOLTA_METRY.RESETALL,
+ payload: null
+ });
+ const numberOfCurves = listCurves.length;
+ if (numberOfCurves <= 0) {
+ return;
+ }
+ const firstCurve = listCurves[0];
+ const {
+ layout
+ } = firstCurve;
+ if (layout !== _list_layout.LIST_LAYOUT.CYCLIC_VOLTAMMETRY) {
+ return;
+ }
+ for (let index = 0; index < listCurves.length; index++) {
+ const curve = listCurves[index];
+ const maxminPeak = getMaxMinPeak(curve);
+ yield (0, _effects.put)({
+ type: _action_type.CYCLIC_VOLTA_METRY.ADD_PAIR_PEAKS,
+ payload: index
+ });
+ for (let pidx = 0; pidx < maxminPeak.max.length; pidx++) {
+ const maxPeak = maxminPeak.max[pidx];
+ yield (0, _effects.put)({
+ type: _action_type.CYCLIC_VOLTA_METRY.ADD_MAX_PEAK,
+ payload: {
+ peak: maxPeak,
+ index: pidx,
+ jcampIdx: index
+ }
+ });
+ const minPeak = maxminPeak.min[pidx];
+ yield (0, _effects.put)({
+ type: _action_type.CYCLIC_VOLTA_METRY.ADD_MIN_PEAK,
+ payload: {
+ peak: minPeak,
+ index: pidx,
+ jcampIdx: index
+ }
+ });
+ const pecker = maxminPeak.pecker[pidx];
+ yield (0, _effects.put)({
+ type: _action_type.CYCLIC_VOLTA_METRY.ADD_PECKER,
+ payload: {
+ peak: pecker,
+ index: pidx,
+ jcampIdx: index
+ }
+ });
+ }
+ const {
+ refIndex
+ } = maxminPeak;
+ if (refIndex > -1) {
+ yield (0, _effects.put)({
+ type: _action_type.CYCLIC_VOLTA_METRY.SELECT_REF_PEAK,
+ payload: {
+ index: refIndex,
+ jcampIdx: index,
+ checked: true
+ }
+ });
+ }
+ }
+ }
+}
+function* setCyclicVoltametryRef(action) {
+ // eslint-disable-line
+ const layoutSt = yield (0, _effects.select)(getLayoutSt);
+ if (layoutSt !== _list_layout.LIST_LAYOUT.CYCLIC_VOLTAMMETRY) {
+ return;
+ }
+ const curveSt = yield (0, _effects.select)(getCurveSt);
+ const {
+ curveIdx
+ } = curveSt;
+ yield (0, _effects.put)({
+ type: _action_type.CYCLIC_VOLTA_METRY.SET_REF,
+ payload: {
+ jcampIdx: curveIdx
+ }
+ });
+}
+function* setInitIntegrations(action) {
+ // eslint-disable-line
+ const curveSt = yield (0, _effects.select)(getCurveSt);
+ const {
+ listCurves
+ } = curveSt;
+ if (listCurves) {
+ for (let index = 0; index < listCurves.length; index++) {
+ const integationSt = yield (0, _effects.select)(getIntegrationSt);
+ const multiplicitySt = yield (0, _effects.select)(getMultiplicitySt);
+ const curve = listCurves[index];
+ const {
+ integration,
+ multiplicity,
+ simulation
+ } = curve;
+ if (integration) {
+ const {
+ integrations
+ } = integationSt;
+ const newArrIntegration = [...integrations];
+ if (index < newArrIntegration.length) {
+ newArrIntegration[index] = integration;
+ } else {
+ newArrIntegration.push(integration);
+ }
+ const payload = Object.assign({}, integationSt, {
+ integrations: newArrIntegration,
+ selectedIdx: index
+ }); // eslint-disable-line
+ yield (0, _effects.put)({
+ type: _action_type.INTEGRATION.RESET_ALL_RDC,
+ payload
+ });
+ }
+ if (multiplicity) {
+ const {
+ multiplicities
+ } = multiplicitySt;
+ const newArrMultiplicities = [...multiplicities];
+ if (index < newArrMultiplicities.length) {
+ newArrMultiplicities[index] = multiplicity;
+ } else {
+ newArrMultiplicities.push(multiplicity);
+ }
+ const payload = Object.assign({}, multiplicitySt, {
+ multiplicities: newArrMultiplicities,
+ selectedIdx: index
+ }); // eslint-disable-line
+ yield (0, _effects.put)({
+ type: _action_type.MULTIPLICITY.RESET_ALL_RDC,
+ payload
+ });
+ }
+ if (simulation) {
+ yield (0, _effects.put)({
+ type: _action_type.SIMULATION.RESET_ALL_RDC,
+ payload: simulation
+ });
+ }
+ }
+ }
+}
+function* setSimulationForCurve(action) {
+ // eslint-disable-line
+ const layoutSt = yield (0, _effects.select)(getLayoutSt);
+ if (!_format.default.isNmrLayout(layoutSt)) return;
+ const curveSt = yield (0, _effects.select)(getCurveSt);
+ const {
+ listCurves,
+ curveIdx
+ } = curveSt;
+ if (!Array.isArray(listCurves) || listCurves.length === 0) return;
+ const targetIdx = Number.isInteger(action.payload) ? action.payload : curveIdx;
+ const targetCurve = listCurves[targetIdx];
+ if (!targetCurve || !targetCurve.simulation) {
+ yield (0, _effects.put)({
+ type: _action_type.SIMULATION.RESET_ALL_RDC,
+ payload: {
+ nmrSimPeaks: []
+ }
+ });
+ return;
+ }
+ yield (0, _effects.put)({
+ type: _action_type.SIMULATION.RESET_ALL_RDC,
+ payload: targetCurve.simulation
+ });
+}
+const multiEntitiesSagas = [(0, _effects.takeEvery)(_action_type.CURVE.SET_ALL_CURVES, setCyclicVoltametry), (0, _effects.takeEvery)(_action_type.CURVE.SET_ALL_CURVES, setInitIntegrations), (0, _effects.takeEvery)(_action_type.CURVE.SELECT_WORKING_CURVE, setSimulationForCurve), (0, _effects.takeEvery)(_action_type.CYCLIC_VOLTA_METRY.SET_FACTOR, setCyclicVoltametryRef)];
+var _default = exports.default = multiEntitiesSagas;
\ No newline at end of file
diff --git a/dist/sagas/saga_multiplicity.js b/dist/sagas/saga_multiplicity.js
new file mode 100644
index 00000000..7529be27
--- /dev/null
+++ b/dist/sagas/saga_multiplicity.js
@@ -0,0 +1,379 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+var _effects = require("redux-saga/effects");
+var _action_type = require("../constants/action_type");
+var _multiplicity_calc = require("../helpers/multiplicity_calc");
+var _multiplicity_manual = require("../helpers/multiplicity_manual");
+const getMetaSt = state => state.meta;
+const getCurveSt = state => state.curve;
+const getMultiplicitySt = state => state.multiplicity.present;
+function* selectMpy(action) {
+ const metaSt = yield (0, _effects.select)(getMetaSt);
+ const mpySt = yield (0, _effects.select)(getMultiplicitySt);
+ const {
+ newData,
+ curveIdx
+ } = action.payload;
+ const {
+ multiplicities
+ } = mpySt;
+ let selectedMulti = multiplicities[curveIdx];
+ if (selectedMulti === false || selectedMulti === undefined) {
+ selectedMulti = {
+ stack: [],
+ shift: 0,
+ smExtext: false,
+ edited: false
+ };
+ }
+ const {
+ xExtent,
+ yExtent,
+ dataPks
+ } = newData;
+ const {
+ shift,
+ stack
+ } = selectedMulti;
+ const {
+ xL,
+ xU
+ } = xExtent;
+ const {
+ yL,
+ yU
+ } = yExtent;
+ let peaks = dataPks.filter(p => xL <= p.x && p.x <= xU && yL <= p.y && p.y <= yU);
+ peaks = peaks.map(pk => ({
+ x: pk.x + shift,
+ y: pk.y
+ }));
+ const newXExtemt = {
+ xL: xL + shift,
+ xU: xU + shift
+ };
+ const coupling = (0, _multiplicity_calc.calcMpyCoup)(peaks, metaSt);
+ const m = {
+ peaks,
+ xExtent: newXExtemt,
+ yExtent,
+ mpyType: coupling.type,
+ js: coupling.js
+ };
+ const newStack = [...stack, m];
+ const newSelectedMulti = Object.assign(
+ // eslint-disable-line
+ {}, selectedMulti, {
+ stack: newStack,
+ smExtext: newXExtemt
+ });
+ const newMultiplicities = [...multiplicities];
+ newMultiplicities[curveIdx] = newSelectedMulti;
+ const payload = Object.assign(
+ // eslint-disable-line
+ {}, mpySt, {
+ multiplicities: newMultiplicities,
+ selectedIdx: curveIdx
+ });
+ yield (0, _effects.put)({
+ type: _action_type.UI.SWEEP.SELECT_MULTIPLICITY_RDC,
+ payload
+ });
+}
+function* addUiPeakToStack(action) {
+ const metaSt = yield (0, _effects.select)(getMetaSt);
+ const mpySt = yield (0, _effects.select)(getMultiplicitySt);
+ const curveSt = yield (0, _effects.select)(getCurveSt);
+ const {
+ curveIdx
+ } = curveSt;
+ const {
+ multiplicities
+ } = mpySt;
+ const selectedMulti = multiplicities[curveIdx];
+ const {
+ shift,
+ stack,
+ smExtext
+ } = selectedMulti;
+ let {
+ x,
+ y
+ } = action.payload; // eslint-disable-line
+ if (!x || !y) return;
+ x += shift;
+ const newPeak = {
+ x,
+ y
+ };
+ const {
+ xL,
+ xU
+ } = smExtext;
+ if (x < xL || xU < x) return;
+ let isDuplicate = false;
+ const newStack = stack.map(k => {
+ if (k.xExtent.xL === xL && k.xExtent.xU === xU) {
+ const existXs = k.peaks.map(pk => pk.x);
+ if (existXs.indexOf(newPeak.x) >= 0) {
+ isDuplicate = true;
+ return k;
+ }
+ const newPks = [...k.peaks, newPeak];
+ const coupling = (0, _multiplicity_calc.calcMpyCoup)(newPks, metaSt);
+ return Object.assign(
+ // eslint-disable-line
+ {}, k, {
+ peaks: newPks,
+ mpyType: coupling.type,
+ js: coupling.js
+ });
+ }
+ return k;
+ });
+ if (isDuplicate) return;
+ const newSelectedMulti = Object.assign({}, selectedMulti, {
+ stack: newStack
+ }); // eslint-disable-line
+ const newMultiplicities = [...multiplicities];
+ newMultiplicities[curveIdx] = newSelectedMulti;
+ const payload = Object.assign({}, mpySt, {
+ multiplicities: newMultiplicities
+ }); // eslint-disable-line
+
+ yield (0, _effects.put)({
+ type: _action_type.MULTIPLICITY.PEAK_ADD_BY_UI_RDC,
+ payload
+ });
+}
+const rmPeakFromStack = function rmPeakFromStack(action, metaSt, mpySt) {
+ let curveIdx = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+ const {
+ peak,
+ xExtent
+ } = action.payload;
+ const {
+ multiplicities
+ } = mpySt;
+ const selectedMulti = multiplicities[curveIdx];
+ const {
+ stack
+ } = selectedMulti;
+ let newStack = stack.map(k => {
+ if (k.xExtent.xL === xExtent.xL && k.xExtent.xU === xExtent.xU) {
+ const newPks = k.peaks.filter(pk => pk.x !== peak.x);
+ const coupling = (0, _multiplicity_calc.calcMpyCoup)(newPks, metaSt);
+ return Object.assign(
+ // eslint-disable-line
+ {}, k, {
+ peaks: newPks,
+ mpyType: coupling.type,
+ js: coupling.js
+ });
+ }
+ return k;
+ });
+ newStack = newStack.filter(k => k.peaks.length !== 0);
+ if (newStack.length === 0) {
+ const newSelectedMulti = Object.assign({}, selectedMulti, {
+ stack: newStack,
+ smExtext: false
+ }); // eslint-disable-line
+ multiplicities[curveIdx] = newSelectedMulti;
+ return Object.assign({}, mpySt, {
+ multiplicities
+ }); // eslint-disable-line
+ }
+ const noSmExtext = newStack.map(k => k.xExtent.xL === xExtent.xL && k.xExtent.xU === xExtent.xU ? 1 : 0).reduce((a, s) => a + s) === 0;
+ const newSmExtext = noSmExtext ? newStack[0].xExtent : xExtent;
+ const newSelectedMulti = Object.assign({}, selectedMulti, {
+ stack: newStack,
+ smExtext: newSmExtext
+ }); // eslint-disable-line
+ const newMultiplicities = [...multiplicities];
+ newMultiplicities[curveIdx] = newSelectedMulti;
+ return Object.assign({}, mpySt, {
+ multiplicities: newMultiplicities
+ }); // eslint-disable-line
+};
+function* rmPanelPeakFromStack(action) {
+ const metaSt = yield (0, _effects.select)(getMetaSt);
+ const mpySt = yield (0, _effects.select)(getMultiplicitySt);
+ const curveSt = yield (0, _effects.select)(getCurveSt);
+ const {
+ curveIdx
+ } = curveSt;
+ const payload = rmPeakFromStack(action, metaSt, mpySt, curveIdx);
+ yield (0, _effects.put)({
+ type: _action_type.MULTIPLICITY.PEAK_RM_BY_PANEL_RDC,
+ payload
+ });
+}
+function* rmUiPeakFromStack(action) {
+ const metaSt = yield (0, _effects.select)(getMetaSt);
+ const mpySt = yield (0, _effects.select)(getMultiplicitySt);
+ const curveSt = yield (0, _effects.select)(getCurveSt);
+ const {
+ curveIdx
+ } = curveSt;
+ const {
+ multiplicities
+ } = mpySt;
+ const selectedMulti = multiplicities[curveIdx];
+ const peak = action.payload;
+ const xExtent = selectedMulti.smExtext;
+ const newAction = Object.assign({}, action, {
+ payload: {
+ peak,
+ xExtent
+ }
+ }); // eslint-disable-line
+
+ const payload = rmPeakFromStack(newAction, metaSt, mpySt, curveIdx);
+ yield (0, _effects.put)({
+ type: _action_type.MULTIPLICITY.PEAK_RM_BY_UI_RDC,
+ payload
+ });
+}
+function* resetInitNmr(action) {
+ const {
+ multiplicity
+ } = action.payload;
+ const curveSt = yield (0, _effects.select)(getCurveSt);
+ const mpySt = yield (0, _effects.select)(getMultiplicitySt);
+ const {
+ curveIdx
+ } = curveSt;
+ const {
+ multiplicities
+ } = mpySt;
+ const newMultiplicities = [...multiplicities];
+ newMultiplicities[curveIdx] = multiplicity;
+ const payload = Object.assign({}, mpySt, {
+ multiplicities: newMultiplicities,
+ selectedIdx: curveIdx
+ }); // eslint-disable-line
+
+ if (multiplicity) {
+ yield (0, _effects.put)({
+ type: _action_type.MULTIPLICITY.RESET_ALL_RDC,
+ payload
+ });
+ }
+ // const metaSt = yield select(getMetaSt);
+ // const mpySt = yield select(getMultiplicitySt);
+
+ // if (!multiplicity) {
+ // yield put({
+ // type: MULTIPLICITY.RESET_ALL_RDC,
+ // payload: mpySt,
+ // });
+ // }
+
+ // const { stack } = multiplicity;
+ // const newStack = stack.map((k) => {
+ // const { peaks } = k;
+ // const coupling = calcMpyCoup(peaks, metaSt);
+ // return Object.assign(
+ // {},
+ // k,
+ // {
+ // peaks,
+ // mpyType: coupling.type,
+ // js: coupling.js,
+ // },
+ // );
+ // });
+ // const payload = Object.assign({}, mpySt, { stack: newStack });
+ // yield put({
+ // type: MULTIPLICITY.RESET_ALL_RDC,
+ // payload,
+ // });
+}
+function* resetOne(action) {
+ const xExtent = action.payload;
+ const metaSt = yield (0, _effects.select)(getMetaSt);
+ const mpySt = yield (0, _effects.select)(getMultiplicitySt);
+ const curveSt = yield (0, _effects.select)(getCurveSt);
+ const {
+ curveIdx
+ } = curveSt;
+ const {
+ multiplicities
+ } = mpySt;
+ const selectedMulti = multiplicities[curveIdx];
+ const {
+ stack
+ } = selectedMulti;
+ const newStack = stack.map(k => {
+ if (k.xExtent.xL === xExtent.xL && k.xExtent.xU === xExtent.xU) {
+ const {
+ peaks
+ } = k;
+ const coupling = (0, _multiplicity_calc.calcMpyCoup)(peaks, metaSt);
+ return Object.assign(
+ // eslint-disable-line
+ {}, k, {
+ peaks,
+ mpyType: coupling.type,
+ js: coupling.js
+ });
+ }
+ return k;
+ });
+ const newSelectedMulti = Object.assign({}, selectedMulti, {
+ stack: newStack
+ }); // eslint-disable-line
+ const newMultiplicities = [...multiplicities];
+ newMultiplicities[curveIdx] = newSelectedMulti;
+ const payload = Object.assign({}, mpySt, {
+ multiplicities: newMultiplicities
+ }); // eslint-disable-line
+ yield (0, _effects.put)({
+ type: _action_type.MULTIPLICITY.RESET_ONE_RDC,
+ payload
+ });
+}
+function* selectMpyType(action) {
+ const mpySt = yield (0, _effects.select)(getMultiplicitySt);
+ const metaSt = yield (0, _effects.select)(getMetaSt);
+ const curveSt = yield (0, _effects.select)(getCurveSt);
+ const {
+ curveIdx
+ } = curveSt;
+ const {
+ multiplicities
+ } = mpySt;
+ const selectedMulti = multiplicities[curveIdx];
+ const {
+ mpyType,
+ xExtent
+ } = action.payload;
+ const {
+ stack
+ } = selectedMulti;
+ const newStack = stack.map(k => {
+ const isTargetStack = k.xExtent.xL === xExtent.xL && k.xExtent.xU === xExtent.xU;
+ if (isTargetStack) return (0, _multiplicity_manual.calcMpyManual)(k, mpyType, metaSt);
+ return k;
+ });
+ const newSelectedMulti = Object.assign({}, selectedMulti, {
+ stack: newStack
+ }); // eslint-disable-line
+ const newMultiplicities = [...multiplicities];
+ newMultiplicities[curveIdx] = newSelectedMulti;
+ const payload = Object.assign({}, mpySt, {
+ multiplicities: newMultiplicities
+ }); // eslint-disable-line
+
+ yield (0, _effects.put)({
+ type: _action_type.MULTIPLICITY.TYPE_SELECT_RDC,
+ payload
+ });
+}
+const multiplicitySagas = [(0, _effects.takeEvery)(_action_type.UI.SWEEP.SELECT_MULTIPLICITY, selectMpy), (0, _effects.takeEvery)(_action_type.MULTIPLICITY.PEAK_ADD_BY_UI_SAG, addUiPeakToStack), (0, _effects.takeEvery)(_action_type.MULTIPLICITY.PEAK_RM_BY_PANEL, rmPanelPeakFromStack), (0, _effects.takeEvery)(_action_type.MULTIPLICITY.PEAK_RM_BY_UI, rmUiPeakFromStack), (0, _effects.takeEvery)(_action_type.MULTIPLICITY.TYPE_SELECT, selectMpyType), (0, _effects.takeEvery)(_action_type.MULTIPLICITY.RESET_ONE, resetOne), (0, _effects.takeEvery)(_action_type.MANAGER.RESET_INIT_NMR, resetInitNmr)];
+var _default = exports.default = multiplicitySagas;
\ No newline at end of file
diff --git a/dist/sagas/saga_ui.js b/dist/sagas/saga_ui.js
new file mode 100644
index 00000000..adf16e94
--- /dev/null
+++ b/dist/sagas/saga_ui.js
@@ -0,0 +1,321 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+var _effects = require("redux-saga/effects");
+var _action_type = require("../constants/action_type");
+var _list_ui = require("../constants/list_ui");
+var _list_layout = require("../constants/list_layout");
+const getUiSt = state => state.ui;
+const getCurveSt = state => state.curve;
+const calcPeaks = payload => {
+ const {
+ xExtent,
+ yExtent,
+ dataPks
+ } = payload;
+ if (!dataPks) return [];
+ const {
+ xL,
+ xU
+ } = xExtent;
+ const {
+ yL,
+ yU
+ } = yExtent;
+ const peaks = dataPks.filter(p => xL <= p.x && p.x <= xU && yL <= p.y && p.y <= yU);
+ return peaks;
+};
+function* selectUiSweep(action) {
+ const uiSt = yield (0, _effects.select)(getUiSt);
+ const {
+ payload
+ } = action;
+ const curveSt = yield (0, _effects.select)(getCurveSt);
+ const {
+ curveIdx
+ } = curveSt;
+ switch (uiSt.sweepType) {
+ case _list_ui.LIST_UI_SWEEP_TYPE.ZOOMIN:
+ yield (0, _effects.put)({
+ type: _action_type.UI.SWEEP.SELECT_ZOOMIN,
+ payload
+ });
+ break;
+ case _list_ui.LIST_UI_SWEEP_TYPE.ZOOMRESET:
+ yield (0, _effects.put)({
+ type: _action_type.UI.SWEEP.SELECT_ZOOMRESET,
+ payload
+ });
+ break;
+ case _list_ui.LIST_UI_SWEEP_TYPE.INTEGRATION_ADD:
+ yield (0, _effects.put)({
+ type: _action_type.UI.SWEEP.SELECT_INTEGRATION,
+ payload: {
+ newData: payload,
+ curveIdx
+ }
+ });
+ break;
+ case _list_ui.LIST_UI_SWEEP_TYPE.MULTIPLICITY_SWEEP_ADD:
+ const peaks = calcPeaks(payload); // eslint-disable-line
+ if (peaks.length === 0) {
+ break;
+ }
+ const newPayload = Object.assign({}, payload, {
+ peaks
+ }); // eslint-disable-line
+
+ yield (0, _effects.put)({
+ type: _action_type.UI.SWEEP.SELECT_INTEGRATION,
+ payload: {
+ newData: newPayload,
+ curveIdx
+ }
+ });
+ yield (0, _effects.put)({
+ type: _action_type.UI.SWEEP.SELECT_MULTIPLICITY,
+ payload: {
+ newData: newPayload,
+ curveIdx
+ }
+ });
+ break;
+ default:
+ break;
+ }
+ return null;
+}
+const getLayoutSt = state => state.layout;
+function* scrollUiWheel(action) {
+ const layoutSt = yield (0, _effects.select)(getLayoutSt);
+ const {
+ payload
+ } = action;
+ const {
+ xExtent,
+ yExtent,
+ direction
+ } = payload;
+ const {
+ yL,
+ yU
+ } = yExtent;
+ const [yeL, yeU] = [yL + (yU - yL) * 0.1, yU - (yU - yL) * 0.1];
+ const scale = direction ? 0.8 : 1.25;
+ let nextExtent = {
+ xExtent: false,
+ yExtent: false
+ };
+ let [nyeL, nyeU, h, nytL, nytU] = [0, 1, 1, 0, 1];
+ switch (layoutSt) {
+ case _list_layout.LIST_LAYOUT.IR:
+ case _list_layout.LIST_LAYOUT.RAMAN:
+ [nyeL, nyeU] = [yeL + (yeU - yeL) * (1 - scale), yeU];
+ h = nyeU - nyeL;
+ [nytL, nytU] = [nyeL - 0.125 * h, nyeU + 0.125 * h];
+ nextExtent = {
+ xExtent,
+ yExtent: {
+ yL: nytL,
+ yU: nytU
+ }
+ };
+ break;
+ case _list_layout.LIST_LAYOUT.MS:
+ [nyeL, nyeU] = [0, yeL + (yeU - yeL) * scale];
+ h = nyeU - nyeL;
+ [nytL, nytU] = [nyeL - 0.125 * h, nyeU + 0.125 * h];
+ nextExtent = {
+ xExtent,
+ yExtent: {
+ yL: nytL,
+ yU: nytU
+ }
+ };
+ break;
+ case _list_layout.LIST_LAYOUT.UVVIS:
+ case _list_layout.LIST_LAYOUT.HPLC_UVVIS:
+ case _list_layout.LIST_LAYOUT.TGA:
+ case _list_layout.LIST_LAYOUT.DSC:
+ case _list_layout.LIST_LAYOUT.XRD:
+ default:
+ [nyeL, nyeU] = [yeL, yeL + (yeU - yeL) * scale];
+ h = nyeU - nyeL;
+ [nytL, nytU] = [nyeL - 0.125 * h, nyeU + 0.125 * h];
+ nextExtent = {
+ xExtent,
+ yExtent: {
+ yL: nytL,
+ yU: nytU
+ }
+ };
+ break;
+ }
+ yield (0, _effects.put)({
+ type: _action_type.UI.SWEEP.SELECT_ZOOMIN,
+ payload: nextExtent
+ });
+}
+const getUiSweepType = state => state.ui.sweepType;
+function* clickUiTarget(action) {
+ const {
+ payload,
+ onPeak,
+ voltammetryPeakIdx,
+ onPecker
+ } = action;
+ const uiSweepType = yield (0, _effects.select)(getUiSweepType);
+ const curveSt = yield (0, _effects.select)(getCurveSt);
+ const {
+ curveIdx
+ } = curveSt;
+ if (uiSweepType === _list_ui.LIST_UI_SWEEP_TYPE.PEAK_ADD && !onPeak) {
+ yield (0, _effects.put)({
+ type: _action_type.EDITPEAK.ADD_POSITIVE,
+ payload: {
+ dataToAdd: payload,
+ curveIdx
+ }
+ });
+ } else if (uiSweepType === _list_ui.LIST_UI_SWEEP_TYPE.PEAK_DELETE && onPeak) {
+ yield (0, _effects.put)({
+ type: _action_type.EDITPEAK.ADD_NEGATIVE,
+ payload: {
+ dataToAdd: payload,
+ curveIdx
+ }
+ });
+ } else if (uiSweepType === _list_ui.LIST_UI_SWEEP_TYPE.ANCHOR_SHIFT && onPeak) {
+ yield (0, _effects.put)({
+ type: _action_type.SHIFT.SET_PEAK,
+ payload: {
+ dataToSet: payload,
+ curveIdx
+ }
+ });
+ } else if (uiSweepType === _list_ui.LIST_UI_SWEEP_TYPE.INTEGRATION_RM && onPeak) {
+ yield (0, _effects.put)({
+ type: _action_type.INTEGRATION.RM_ONE,
+ payload: {
+ dataToRemove: payload,
+ curveIdx
+ }
+ });
+ } else if (uiSweepType === _list_ui.LIST_UI_SWEEP_TYPE.MULTIPLICITY_ONE_RM && onPeak) {
+ yield (0, _effects.put)({
+ type: _action_type.INTEGRATION.RM_ONE,
+ payload: {
+ dataToRemove: payload,
+ curveIdx
+ }
+ });
+ } else if (uiSweepType === _list_ui.LIST_UI_SWEEP_TYPE.INTEGRATION_SET_REF && onPeak) {
+ yield (0, _effects.put)({
+ type: _action_type.INTEGRATION.SET_REF,
+ payload: {
+ refData: payload,
+ curveIdx
+ }
+ });
+ } else if (uiSweepType === _list_ui.LIST_UI_SWEEP_TYPE.MULTIPLICITY_ONE_CLICK && onPeak) {
+ const {
+ xExtent,
+ xL,
+ xU
+ } = payload;
+ if (xExtent) {
+ yield (0, _effects.put)({
+ type: _action_type.MULTIPLICITY.ONE_CLICK_BY_UI,
+ payload: {
+ payloadData: xExtent,
+ curveIdx
+ }
+ });
+ } else if (xL && xU) {
+ yield (0, _effects.put)({
+ type: _action_type.MULTIPLICITY.ONE_CLICK_BY_UI,
+ payload: {
+ payloadData: {
+ xL,
+ xU
+ },
+ curveIdx
+ }
+ });
+ }
+ } else if (uiSweepType === _list_ui.LIST_UI_SWEEP_TYPE.MULTIPLICITY_PEAK_ADD) {
+ yield (0, _effects.put)({
+ type: _action_type.MULTIPLICITY.PEAK_ADD_BY_UI_SAG,
+ payload
+ });
+ } else if (uiSweepType === _list_ui.LIST_UI_SWEEP_TYPE.MULTIPLICITY_PEAK_RM && onPeak) {
+ yield (0, _effects.put)({
+ type: _action_type.MULTIPLICITY.PEAK_RM_BY_UI,
+ payload
+ });
+ } else if (uiSweepType === _list_ui.LIST_UI_SWEEP_TYPE.CYCLIC_VOLTA_ADD_MAX_PEAK && !onPeak) {
+ yield (0, _effects.put)({
+ type: _action_type.CYCLIC_VOLTA_METRY.ADD_MAX_PEAK,
+ payload: {
+ peak: payload,
+ index: voltammetryPeakIdx,
+ jcampIdx: curveIdx
+ }
+ });
+ } else if (uiSweepType === _list_ui.LIST_UI_SWEEP_TYPE.CYCLIC_VOLTA_RM_MAX_PEAK && onPeak) {
+ yield (0, _effects.put)({
+ type: _action_type.CYCLIC_VOLTA_METRY.REMOVE_MAX_PEAK,
+ payload: {
+ index: voltammetryPeakIdx,
+ jcampIdx: curveIdx
+ }
+ });
+ } else if (uiSweepType === _list_ui.LIST_UI_SWEEP_TYPE.CYCLIC_VOLTA_ADD_MIN_PEAK && !onPeak) {
+ yield (0, _effects.put)({
+ type: _action_type.CYCLIC_VOLTA_METRY.ADD_MIN_PEAK,
+ payload: {
+ peak: payload,
+ index: voltammetryPeakIdx,
+ jcampIdx: curveIdx
+ }
+ });
+ } else if (uiSweepType === _list_ui.LIST_UI_SWEEP_TYPE.CYCLIC_VOLTA_RM_MIN_PEAK && onPeak) {
+ yield (0, _effects.put)({
+ type: _action_type.CYCLIC_VOLTA_METRY.REMOVE_MIN_PEAK,
+ payload: {
+ index: voltammetryPeakIdx,
+ jcampIdx: curveIdx
+ }
+ });
+ } else if (uiSweepType === _list_ui.LIST_UI_SWEEP_TYPE.CYCLIC_VOLTA_ADD_PECKER && !onPecker) {
+ yield (0, _effects.put)({
+ type: _action_type.CYCLIC_VOLTA_METRY.ADD_PECKER,
+ payload: {
+ peak: payload,
+ index: voltammetryPeakIdx,
+ jcampIdx: curveIdx
+ }
+ });
+ } else if (uiSweepType === _list_ui.LIST_UI_SWEEP_TYPE.CYCLIC_VOLTA_RM_PECKER && onPecker) {
+ yield (0, _effects.put)({
+ type: _action_type.CYCLIC_VOLTA_METRY.REMOVE_PECKER,
+ payload: {
+ index: voltammetryPeakIdx,
+ jcampIdx: curveIdx
+ }
+ });
+ } else if (uiSweepType === _list_ui.LIST_UI_SWEEP_TYPE.CYCLIC_VOLTA_SET_REF && onPeak) {
+ yield (0, _effects.put)({
+ type: _action_type.CYCLIC_VOLTA_METRY.SET_REF,
+ payload: {
+ index: voltammetryPeakIdx,
+ jcampIdx: curveIdx
+ }
+ });
+ }
+}
+const managerSagas = [(0, _effects.takeEvery)(_action_type.UI.CLICK_TARGET, clickUiTarget), (0, _effects.takeEvery)(_action_type.UI.SWEEP.SELECT, selectUiSweep), (0, _effects.takeEvery)(_action_type.UI.WHEEL.SCROLL, scrollUiWheel)];
+var _default = exports.default = managerSagas;
\ No newline at end of file
diff --git a/dist/setupTests.js b/dist/setupTests.js
new file mode 100644
index 00000000..fc453d7d
--- /dev/null
+++ b/dist/setupTests.js
@@ -0,0 +1,8 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _enzyme = _interopRequireDefault(require("enzyme"));
+var _enzymeAdapterReact = _interopRequireDefault(require("@wojtekmaj/enzyme-adapter-react-17"));
+_enzyme.default.configure({
+ adapter: new _enzymeAdapterReact.default()
+});
\ No newline at end of file
diff --git a/dist/third_party/jAnalyzer.js b/dist/third_party/jAnalyzer.js
new file mode 100644
index 00000000..7d25625b
--- /dev/null
+++ b/dist/third_party/jAnalyzer.js
@@ -0,0 +1,590 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = void 0;
+/* eslint-disable */
+// https://github.com/cheminfo-js/spectra/blob/master/packages/spectra-data/src/peakPicking/jAnalyzer.js
+
+/*
+ * This library implements the J analyser described by Cobas et al in the paper:
+ * A two-stage approach to automatic determination of 1H NMR coupling constants
+ */
+const patterns = ['s', 'd', 't', 'q', 'quint', 'h', 'sept', 'o', 'n'];
+let symRatio = 1.5;
+let maxErrorIter1 = 2.5; // Hz
+let maxErrorIter2 = 1; // Hz
+var _default = exports.default = {
+ /**
+ * The compilation process implements at the first stage a normalization procedure described by Golotvin et al.
+ * embedding in peak-component-counting method described by Hoyes et al.
+ * @param {object} signal
+ * @private
+ */
+ compilePattern: function compilePattern(signal) {
+ signal.multiplicity = 'm';
+ // 1.1 symmetrize
+ // It will add a set of peaks(signal.peaksComp) to the signal that will be used during
+ // the compilation process. The unit of those peaks will be in Hz
+ signal.symRank = symmetrizeChoiseBest(signal, maxErrorIter1, 1);
+ signal.asymmetric = true;
+ // Is the signal symmetric?
+ if (signal.symRank >= 0.95 && signal.peaksComp.length < 32) {
+ signal.asymmetric = false;
+ var i, j, n, P1, n2, maxFlagged;
+ let k = 1;
+ let Jc = [];
+
+ // Loop over the possible number of coupling contributing to the multiplet
+ for (n = 0; n < 9; n++) {
+ // 1.2 Normalize. It makes a deep copy of the peaks before to modify them.
+ let peaks = normalize(signal, n);
+ // signal.peaksCompX = peaks;
+ let validPattern = false; // It will change to true, when we find the good patter
+ // Lets check if the signal could be a singulet.
+ if (peaks.length === 1 && n === 0) {
+ validPattern = true;
+ } else {
+ if (peaks.length <= 1) {
+ continue;
+ }
+ }
+ // 1.3 Establish a range for the Heights Hi [peaks.intensity*0.85,peaks.intensity*1.15];
+ let ranges = getRanges(peaks);
+ n2 = Math.pow(2, n);
+
+ // 1.4 Find a combination of integer heights Hi, one from each Si, that sums to 2^n.
+ let heights = null;
+ let counter = 1;
+ while (!validPattern && (heights = getNextCombination(ranges, n2)) !== null && counter < 400) {
+ // 2.1 Number the components of the multiplet consecutively from 1 to 2n,
+ // starting at peak 1
+ let numbering = new Array(heights.length);
+ k = 1;
+ for (i = 0; i < heights.length; i++) {
+ numbering[i] = new Array(heights[i]);
+ for (j = 0; j < heights[i]; j++) {
+ numbering[i][j] = k++;
+ }
+ }
+ Jc = []; // The array to store the detected j-coupling
+ // 2.2 Set j = 1; J1 = P2 - P1. Flag components 1 and 2 as accounted for.
+ j = 1;
+ Jc.push(peaks[1].x - peaks[0].x);
+ P1 = peaks[0].x;
+ numbering[0].splice(0, 1); // Flagged
+ numbering[1].splice(0, 1); // Flagged
+ k = 1;
+ let nFlagged = 2;
+ maxFlagged = Math.pow(2, n) - 1;
+ while (Jc.length < n && nFlagged < maxFlagged && k < peaks.length) {
+ counter += 1;
+ // 4.1. Increment j. Set k to the number of the first unflagged component.
+ j++;
+ while (k < peaks.length && numbering[k].length === 0) {
+ k++;
+ }
+ if (k < peaks.length) {
+ // 4.2 Jj = Pk - P1.
+ Jc.push(peaks[k].x - peaks[0].x);
+ // Flag component k and, for each sum of the...
+ numbering[k].splice(0, 1); // Flageed
+ nFlagged++;
+ // Flag the other components of the multiplet
+ for (let u = 2; u <= j; u++) {
+ // TODO improve those loops
+ let jSum = 0;
+ for (i = 0; i < u; i++) {
+ jSum += Jc[i];
+ }
+ for (i = 1; i < numbering.length; i++) {
+ // Maybe 0.25 Hz is too much?
+ if (Math.abs(peaks[i].x - (P1 + jSum)) < 0.25) {
+ numbering[i].splice(0, 1); // Flageed
+ nFlagged++;
+ break;
+ }
+ }
+ }
+ }
+ }
+ // Calculate the ideal patter by using the extracted j-couplings
+ let pattern = idealPattern(Jc);
+ // Compare the ideal pattern with the proposed intensities.
+ // All the intensities have to match to accept the multiplet
+ validPattern = true;
+ for (i = 0; i < pattern.length; i++) {
+ if (pattern[i].intensity !== heights[i]) {
+ validPattern = false;
+ }
+ }
+ }
+ // If we found a valid pattern we should inform about the pattern.
+ if (validPattern) {
+ updateSignal(signal, Jc);
+ }
+ }
+ }
+ // Before to return, change the units of peaksComp from Hz to PPM again
+ for (i = 0; i < signal.peaksComp.length; i++) {
+ signal.peaksComp[i].x /= signal.observe;
+ }
+ }
+};
+/**
+ * @private
+ * update the signal
+ * @param {*} signal
+ * @param {*} Jc
+ */
+function updateSignal(signal, Jc) {
+ // Update the limits of the signal
+ let peaks = signal.peaksComp; // Always in Hz
+ let nbPeaks = peaks.length;
+ signal.startX = peaks[0].x / signal.observe - peaks[0].width;
+ signal.stopX = peaks[nbPeaks - 1].x / signal.observe + peaks[nbPeaks - 1].width;
+
+ // signal.integralData.from = peaks[0].x / signal.observe - peaks[0].width * 3;
+ // signal.integralData.to =
+ // peaks[nbPeaks - 1].x / signal.observe + peaks[nbPeaks - 1].width * 3;
+
+ // Compile the pattern and format the constant couplings
+ signal.maskPattern = signal.mask2;
+ signal.multiplicity = abstractPattern(signal, Jc);
+ signal.pattern = signal.multiplicity; // Our library depends on this parameter, but it is old
+ // console.log(signal);
+ /* if (DEBUG) {
+ console.log('Final j-couplings: ' + JSON.stringify(Jc));
+ }*/
+}
+
+/**
+ * Returns the multiplet in the compact format
+ * @param {object} signal
+ * @param {object} Jc
+ * @return {string}
+ * @private
+ */
+function abstractPattern(signal, Jc) {
+ let tol = 0.05;
+ let i;
+ let pattern = '';
+ let cont = 1;
+ let newNmrJs = [];
+ if (Jc && Jc.length > 0) {
+ Jc.sort(function (a, b) {
+ return Math.abs(b) - Math.abs(a);
+ });
+ for (i = 0; i < Jc.length - 1; i++) {
+ if (Math.abs(Jc[i] - Jc[i + 1]) < tol) {
+ cont++;
+ } else {
+ newNmrJs.push({
+ coupling: Math.abs(Jc[i]),
+ multiplicity: patterns[cont]
+ });
+ pattern += patterns[cont];
+ cont = 1;
+ }
+ }
+ newNmrJs.push({
+ coupling: Math.abs(Jc[i]),
+ multiplicity: patterns[cont]
+ });
+ pattern += patterns[cont];
+ signal.nmrJs = newNmrJs;
+ } else {
+ pattern = 's';
+ // if (Math.abs(signal.startX - signal.stopX) * signal.observe > 16) {
+ // pattern = 'br s';
+ // }
+ }
+ return pattern;
+}
+
+/**
+ * This function creates an ideal pattern from the given J-couplings
+ * @private
+ * @param {Array} Jc
+ * @return {*[]}
+ * @private
+ */
+function idealPattern(Jc) {
+ let hsum = Math.pow(2, Jc.length);
+ let i, j;
+ let pattern = [{
+ x: 0,
+ intensity: hsum
+ }];
+ // To split the initial height
+ for (i = 0; i < Jc.length; i++) {
+ for (j = pattern.length - 1; j >= 0; j--) {
+ pattern.push({
+ x: pattern[j].x + Jc[i] / 2,
+ intensity: pattern[j].intensity / 2
+ });
+ pattern[j].x = pattern[j].x - Jc[i] / 2;
+ pattern[j].intensity = pattern[j].intensity / 2;
+ }
+ }
+ // To sum the heights in the same positions
+ pattern.sort(function compare(a, b) {
+ return a.x - b.x;
+ });
+ for (j = pattern.length - 2; j >= 0; j--) {
+ if (Math.abs(pattern[j].x - pattern[j + 1].x) < 0.1) {
+ pattern[j].intensity += pattern[j + 1].intensity;
+ pattern.splice(j + 1, 1);
+ }
+ }
+ return pattern;
+}
+
+/**
+ * Find a combination of integer heights Hi, one from each Si, that sums to 2n.
+ * @param {object} ranges
+ * @param {number} value
+ * @return {*}
+ * @private
+ */
+function getNextCombination(ranges, value) {
+ let half = Math.ceil(ranges.values.length * 0.5);
+ let lng = ranges.values.length;
+ let sum = 0;
+ let i, ok;
+ while (sum !== value) {
+ // Update the indexes to point at the next possible combination
+ ok = false;
+ while (!ok) {
+ ok = true;
+ ranges.currentIndex[ranges.active]++;
+ if (ranges.currentIndex[ranges.active] >= ranges.values[ranges.active].length) {
+ // In this case, there is no more possible combinations
+ if (ranges.active + 1 === half) {
+ return null;
+ } else {
+ // If this happens we need to try the next active peak
+ ranges.currentIndex[ranges.active] = 0;
+ ok = false;
+ ranges.active++;
+ }
+ } else {
+ ranges.active = 0;
+ }
+ }
+ // Sum the heights for this combination
+ sum = 0;
+ for (i = 0; i < half; i++) {
+ sum += ranges.values[i][ranges.currentIndex[i]] * 2;
+ }
+ if (ranges.values.length % 2 !== 0) {
+ sum -= ranges.values[half - 1][ranges.currentIndex[half - 1]];
+ }
+ }
+ // If the sum is equal to the expected value, fill the array to return
+ if (sum === value) {
+ let heights = new Array(lng);
+ for (i = 0; i < half; i++) {
+ heights[i] = ranges.values[i][ranges.currentIndex[i]];
+ heights[lng - i - 1] = ranges.values[i][ranges.currentIndex[i]];
+ }
+ return heights;
+ }
+ return null;
+}
+
+/**
+ * This function generates the possible values that each peak can contribute
+ * to the multiplet.
+ * @param {Array} peaks Array of objects with peaks information {intensity}
+ * @return {{values: Array, currentIndex: Array, active: number}}
+ * @private
+ */
+function getRanges(peaks) {
+ let ranges = new Array(peaks.length);
+ let currentIndex = new Array(peaks.length);
+ let min, max;
+ ranges[0] = [1];
+ ranges[peaks.length - 1] = [1];
+ currentIndex[0] = -1;
+ currentIndex[peaks.length - 1] = 0;
+ for (let i = 1; i < peaks.length - 1; i++) {
+ min = Math.round(peaks[i].intensity * 0.85);
+ max = Math.round(peaks[i].intensity * 1.15);
+ ranges[i] = [];
+ for (let j = min; j <= max; j++) {
+ ranges[i].push(j);
+ }
+ currentIndex[i] = 0;
+ }
+ return {
+ values: ranges,
+ currentIndex: currentIndex,
+ active: 0
+ };
+}
+/**
+ * Performs a symmetrization of the signal by using different aproximations to the center.
+ * It will return the result of the symmetrization that removes less peaks from the signal
+ * @param {object} signal
+ * @param {number} maxError
+ * @param {number} iteration
+ * @return {*}
+ * @private
+ */
+function symmetrizeChoiseBest(signal, maxError, iteration) {
+ let symRank1 = symmetrize(signal, maxError, iteration);
+ let tmpPeaks = signal.peaksComp;
+ let tmpMask = signal.mask;
+ let cs = signal.delta1;
+ signal.delta1 = (signal.peaks[0].x + signal.peaks[signal.peaks.length - 1].x) / 2;
+ let symRank2 = symmetrize(signal, maxError, iteration);
+ if (signal.peaksComp.length > tmpPeaks.length) {
+ return symRank2;
+ } else {
+ signal.delta1 = cs;
+ signal.peaksComp = tmpPeaks;
+ signal.mask = tmpMask;
+ return symRank1;
+ }
+}
+
+/**
+ * This function will return a set of symmetric peaks that will
+ * be the enter point for the patter compilation process.
+ * @param {object} signal
+ * @param {number} maxError
+ * @param {number} iteration
+ * @return {number}
+ * @private
+ */
+function symmetrize(signal, maxError, iteration) {
+ // Before to symmetrize we need to keep only the peaks that possibly conforms the multiplete
+ let max, min, avg, ratio, avgWidth, i;
+ let peaks = new Array(signal.peaks.length);
+ // Make a deep copy of the peaks and convert PPM ot HZ
+ for (i = 0; i < peaks.length; i++) {
+ peaks[i] = {
+ x: signal.peaks[i].x * signal.observe,
+ intensity: signal.peaks[i].intensity,
+ width: signal.peaks[i].width
+ };
+ }
+ // Join the peaks that are closer than 0.25 Hz
+ for (i = peaks.length - 2; i >= 0; i--) {
+ if (Math.abs(peaks[i].x - peaks[i + 1].x) < 0.25) {
+ peaks[i].x = peaks[i].x * peaks[i].intensity + peaks[i + 1].x * peaks[i + 1].intensity;
+ peaks[i].intensity = peaks[i].intensity + peaks[i + 1].intensity;
+ peaks[i].x /= peaks[i].intensity;
+ peaks[i].intensity /= 2;
+ peaks[i].width += peaks[i + 1].width;
+ peaks.splice(i + 1, 1);
+ }
+ }
+ signal.peaksComp = peaks;
+ let nbPeaks = peaks.length;
+ let mask = new Array(nbPeaks);
+ signal.mask = mask;
+ let left = 0;
+ let right = peaks.length - 1;
+ let cs = signal.delta1 * signal.observe;
+ let middle = [(peaks[0].x + peaks[nbPeaks - 1].x) / 2, 1];
+ maxError = error(Math.abs(cs - middle[0]));
+ let heightSum = 0;
+ // We try to symmetrize the extreme peaks. We consider as candidates for symmetricing those which have
+ // ratio smaller than 3
+ for (i = 0; i < nbPeaks; i++) {
+ mask[i] = true;
+ heightSum += signal.peaks[i].intensity;
+ }
+ while (left <= right) {
+ mask[left] = true;
+ mask[right] = true;
+ if (left === right) {
+ if (nbPeaks > 2 && Math.abs(peaks[left].x - cs) > maxError) {
+ mask[left] = false;
+ }
+ } else {
+ max = Math.max(peaks[left].intensity, peaks[right].intensity);
+ min = Math.min(peaks[left].intensity, peaks[right].intensity);
+ ratio = max / min;
+ if (ratio > symRatio) {
+ if (peaks[left].intensity === min) {
+ mask[left] = false;
+ right++;
+ } else {
+ mask[right] = false;
+ left--;
+ }
+ } else {
+ let diffL = Math.abs(peaks[left].x - cs);
+ let diffR = Math.abs(peaks[right].x - cs);
+ if (Math.abs(diffL - diffR) < maxError) {
+ avg = Math.min(peaks[left].intensity, peaks[right].intensity);
+ avgWidth = Math.min(peaks[left].width, peaks[right].width);
+ peaks[left].intensity = peaks[right].intensity = avg;
+ peaks[left].width = peaks[right].width = avgWidth;
+ middle = [middle[0] + (peaks[right].x + peaks[left].x) / 2, middle[1] + 1];
+ } else {
+ if (Math.max(diffL, diffR) === diffR) {
+ mask[right] = false;
+ left--;
+ } else {
+ mask[left] = false;
+ right++;
+ }
+ }
+ }
+ }
+ left++;
+ right--;
+ // Only alter cs if it is the first iteration of the sym process.
+ if (iteration === 1) {
+ cs = chemicalShift(peaks, mask);
+ // There is not more available peaks
+ if (isNaN(cs)) {
+ return 0;
+ }
+ }
+ maxError = error(Math.abs(cs - middle[0] / middle[1]));
+ }
+ // To remove the weak peaks and recalculate the cs
+ for (i = nbPeaks - 1; i >= 0; i--) {
+ if (mask[i] === false) {
+ peaks.splice(i, 1);
+ }
+ }
+ cs = chemicalShift(peaks);
+ if (isNaN(cs)) {
+ return 0;
+ }
+ signal.delta1 = cs / signal.observe;
+ // Now, the peak should be symmetric in heights, but we need to know if it is symmetric in x
+ let symFactor = 0;
+ let weight = 0;
+ if (peaks.length > 1) {
+ for (i = Math.ceil(peaks.length / 2) - 1; i >= 0; i--) {
+ symFactor += (3 + Math.min(Math.abs(peaks[i].x - cs), Math.abs(peaks[peaks.length - 1 - i].x - cs))) / (3 + Math.max(Math.abs(peaks[i].x - cs), Math.abs(peaks[peaks.length - 1 - i].x - cs))) * peaks[i].intensity;
+ weight += peaks[i].intensity;
+ }
+ symFactor /= weight;
+ } else {
+ if (peaks.length === 1) {
+ symFactor = 1;
+ }
+ }
+ let newSumHeights = 0;
+ for (i = 0; i < peaks.length; i++) {
+ newSumHeights += peaks[i].intensity;
+ }
+ symFactor -= (heightSum - newSumHeights) / heightSum * 0.12; // Removed peaks penalty
+ // Sometimes we need a second opinion after the first symmetrization.
+ if (symFactor > 0.8 && symFactor < 0.97 && iteration < 2) {
+ return symmetrize(signal, maxErrorIter2, 2);
+ } else {
+ // Center the given pattern at cs and symmetrize x
+ if (peaks.length > 1) {
+ let dxi;
+ for (i = Math.ceil(peaks.length / 2) - 1; i >= 0; i--) {
+ dxi = (peaks[i].x - peaks[peaks.length - 1 - i].x) / 2.0;
+ peaks[i].x = cs + dxi;
+ peaks[peaks.length - 1 - i].x = cs - dxi;
+ }
+ }
+ }
+ return symFactor;
+}
+/**
+ * Error validator
+ * @param {number} value
+ * @return {number}
+ * @private
+ */
+function error(value) {
+ let maxError = value * 2.5;
+ if (maxError < 0.75) {
+ maxError = 0.75;
+ }
+ if (maxError > 3) {
+ maxError = 3;
+ }
+ return maxError;
+}
+/**
+ * @private
+ * 2 stages normalizarion of the peaks heights to Math.pow(2,n).
+ * Creates a new mask with the peaks that could contribute to the multiplete
+ * @param {object} signal
+ * @param {number} n
+ * @return {*}
+ */
+function normalize(signal, n) {
+ // Perhaps this is slow
+ let peaks = JSON.parse(JSON.stringify(signal.peaksComp));
+ let norm = 0;
+ let norm2 = 0;
+ for (var i = 0; i < peaks.length; i++) {
+ norm += peaks[i].intensity;
+ }
+ norm = Math.pow(2, n) / norm;
+ signal.mask2 = JSON.parse(JSON.stringify(signal.mask));
+ let index = signal.mask2.length - 1;
+ for (i = peaks.length - 1; i >= 0; i--) {
+ peaks[i].intensity *= norm;
+ while (index >= 0 && signal.mask2[index] === false) {
+ index--;
+ }
+ if (peaks[i].intensity < 0.75) {
+ peaks.splice(i, 1);
+ signal.mask2[index] = false;
+ } else {
+ norm2 += peaks[i].intensity;
+ }
+ index--;
+ }
+ norm2 = Math.pow(2, n) / norm2;
+ for (i = peaks.length - 1; i >= 0; i--) {
+ peaks[i].intensity *= norm2;
+ }
+ return peaks;
+}
+
+/**
+ * @private
+ * Calculates the chemical shift as the weighted sum of the peaks
+ * @param {Array} peaks
+ * @param {Array} mask
+ * @return {number}
+ */
+function chemicalShift(peaks, mask) {
+ let sum = 0;
+ let cs = 0;
+ let i, area;
+ if (mask) {
+ for (i = 0; i < peaks.length; i++) {
+ if (mask[i] === true) {
+ area = getArea(peaks[i]);
+ sum += area;
+ cs += area * peaks[i].x;
+ }
+ }
+ } else {
+ for (i = 0; i < peaks.length; i++) {
+ area = getArea(peaks[i]);
+ sum += area;
+ cs += area * peaks[i].x;
+ }
+ }
+ return cs / sum;
+}
+
+/**
+ * Return the area of a Lorentzian function
+ * @param {object} peak - object with peak information
+ * @return {number}
+ * @private
+ */
+function getArea(peak) {
+ return Math.abs(peak.intensity * peak.width * 1.57); // 1.772453851);
+}
\ No newline at end of file
diff --git a/dist/third_party/peakInterval.js b/dist/third_party/peakInterval.js
new file mode 100644
index 00000000..406996d0
--- /dev/null
+++ b/dist/third_party/peakInterval.js
@@ -0,0 +1,105 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.getPeakIntervals = void 0;
+var _mlSavitzkyGolayGeneralized = _interopRequireDefault(require("ml-savitzky-golay-generalized"));
+// https://github.com/mljs/global-spectral-deconvolution/blob/master/src/gsd.js
+
+/* eslint-disable no-plusplus, operator-linebreak */
+
+const options = {
+ sgOptions: {
+ windowSize: 9,
+ polynomial: 3
+ },
+ minMaxRatio: 0.00025,
+ broadRatio: 0.0,
+ maxCriteria: true,
+ smoothY: true,
+ realTopDetection: false,
+ heightFactor: 0,
+ boundaries: false,
+ derivativeThreshold: -1
+};
+const getPeakIntervals = entity => {
+ const data = entity.spectra[0].data[0];
+ const X = data.x;
+ const dX = X[1] - X[0];
+ const Y = (0, _mlSavitzkyGolayGeneralized.default)(data.y, data.x, {
+ windowSize: options.sgOptions.windowSize,
+ polynomial: options.sgOptions.polynomial,
+ derivative: 0
+ });
+ const dY = (0, _mlSavitzkyGolayGeneralized.default)(data.y, data.x, {
+ windowSize: options.sgOptions.windowSize,
+ polynomial: options.sgOptions.polynomial,
+ derivative: 1
+ });
+ const ddY = (0, _mlSavitzkyGolayGeneralized.default)(data.y, data.x, {
+ windowSize: options.sgOptions.windowSize,
+ polynomial: options.sgOptions.polynomial,
+ derivative: 2
+ });
+ let maxDdy = 0;
+ let maxY = 0;
+ for (let i = 0; i < Y.length; i++) {
+ if (Math.abs(ddY[i]) > maxDdy) {
+ maxDdy = Math.abs(ddY[i]);
+ }
+ if (Math.abs(Y[i]) > maxY) {
+ maxY = Math.abs(Y[i]);
+ }
+ }
+ let lastMax = null;
+ let lastMin = null;
+ const minddY = new Array(Y.length - 2);
+ const intervalL = new Array(Y.length);
+ const intervalR = new Array(Y.length);
+ const broadMask = new Array(Y.length - 2);
+ let minddYLen = 0;
+ let intervalLLen = 0;
+ let intervalRLen = 0;
+ let broadMaskLen = 0;
+ for (let i = 1; i < Y.length - 1; ++i) {
+ // filter based on derivativeThreshold
+ if (Math.abs(dY[i]) > options.derivativeThreshold) {
+ // Minimum in first derivative
+ if (dY[i] < dY[i - 1] && dY[i] <= dY[i + 1] || dY[i] <= dY[i - 1] && dY[i] < dY[i + 1]) {
+ lastMin = {
+ x: X[i],
+ index: i
+ };
+ if (dX > 0 && lastMax !== null) {
+ intervalL[intervalLLen++] = lastMax;
+ intervalR[intervalRLen++] = lastMin;
+ }
+ }
+
+ // Maximum in first derivative
+ if (dY[i] >= dY[i - 1] && dY[i] > dY[i + 1] || dY[i] > dY[i - 1] && dY[i] >= dY[i + 1]) {
+ lastMax = {
+ x: X[i],
+ index: i
+ };
+ if (dX < 0 && lastMin !== null) {
+ intervalL[intervalLLen++] = lastMax;
+ intervalR[intervalRLen++] = lastMin;
+ }
+ }
+ }
+ // Minimum in second derivative
+ if (ddY[i] < ddY[i - 1] && ddY[i] < ddY[i + 1]) {
+ // TODO should we change this to have 3 arrays ? Huge overhead creating arrays
+ minddY[minddYLen++] = i; // ( [X[i], Y[i], i] );
+ broadMask[broadMaskLen++] = Math.abs(ddY[i]) <= options.broadRatio * maxDdy;
+ }
+ }
+ return {
+ intervalL,
+ intervalR
+ };
+};
+exports.getPeakIntervals = getPeakIntervals;
\ No newline at end of file
diff --git a/src/__tests__/fixtures/nmr13c_dept_jcamp.js b/src/__tests__/fixtures/nmr13c_dept_jcamp.js
index 30204ba8..77b767f4 100644
--- a/src/__tests__/fixtures/nmr13c_dept_jcamp.js
+++ b/src/__tests__/fixtures/nmr13c_dept_jcamp.js
@@ -3281,6 +3281,28 @@ $$ === CHEMSPECTRA ===
##$OBSERVEDMULTIPLETS=
##$OBSERVEDMULTIPLETSPEAKS=
+$$ === CHEMSPECTRA SIMULATION ===
+##$CSSIMULATIONPEAKS=
+10.123456
+11.123456
+12.123456
+13.123456
+14.123456
+15.123456
+16.123456
+17.123456
+18.123456
+19.123456
+20.123456
+21.123456
+28.550000190734863
+28.59999942779541
+33.29999923706055
+107.20000076293945
+143.5500030517578
+147.8000030517578
+151.35000610351562
+154.8499984741211
##END=
diff --git a/src/__tests__/fixtures/nmr1h_2_jcamp.js b/src/__tests__/fixtures/nmr1h_2_jcamp.js
index 4d9cc5a1..31c8f5f3 100644
--- a/src/__tests__/fixtures/nmr1h_2_jcamp.js
+++ b/src/__tests__/fixtures/nmr1h_2_jcamp.js
@@ -2518,6 +2518,17 @@ $$ === CHEMSPECTRA INTEGRALS AND MULTIPLETS ===
(1, 1.845019816906854, 288947400)
$$ === CHEMSPECTRA SIMULATION ===
##$CSSIMULATIONPEAKS=
+1.10
+1.25
+1.50
+2.75
+3.10
+3.10
+5.50
+7.25
+7.25
+9.00
+9.45
##END=
diff --git a/src/__tests__/fixtures/nmr_result_alt.js b/src/__tests__/fixtures/nmr_result_alt.js
new file mode 100644
index 00000000..1988f4e2
--- /dev/null
+++ b/src/__tests__/fixtures/nmr_result_alt.js
@@ -0,0 +1,71 @@
+/* eslint-disable */
+import nmrSvg from './nmr_svg';
+
+const nmrResultAlt = {
+ outline: {
+ code: 200,
+ text: 'Alt load from files.',
+ },
+ output: {
+ result: [
+ {
+ id: 2,
+ type: 'nmr;13C;1d',
+ svgs: [nmrSvg],
+ statistics: {
+ accept: 2,
+ warning: 1,
+ reject: 2,
+ missing: 1,
+ total: 6,
+ },
+ shifts: [
+ {
+ atom: 1,
+ prediction: 128.4000015258789,
+ real: 116.0,
+ diff: 12.400001525878906,
+ status: 'warning',
+ },
+ {
+ atom: 2,
+ prediction: 118.80000305175781,
+ real: 104.5,
+ diff: 14.300003051757812,
+ status: 'reject',
+ },
+ {
+ atom: 3,
+ prediction: 140.7500000000000,
+ real: 124.2,
+ diff: 16.55,
+ status: 'accept',
+ },
+ {
+ atom: 4,
+ prediction: 151.2500000000000,
+ real: 139.0,
+ diff: 12.25,
+ status: 'accept',
+ },
+ {
+ atom: 5,
+ prediction: 134.1999969482422,
+ real: 120.0,
+ diff: 14.199996948242188,
+ status: 'reject',
+ },
+ {
+ atom: 6,
+ prediction: 147.13500213623047,
+ real: 0.0,
+ diff: 0.0,
+ status: 'missing',
+ },
+ ],
+ },
+ ],
+ },
+};
+
+export default nmrResultAlt;
diff --git a/src/__tests__/units/reducers/reducer_forecast.test.tsx b/src/__tests__/units/reducers/reducer_forecast.test.tsx
index 8ba1d97c..c2457216 100644
--- a/src/__tests__/units/reducers/reducer_forecast.test.tsx
+++ b/src/__tests__/units/reducers/reducer_forecast.test.tsx
@@ -9,6 +9,7 @@ describe('Test redux reducer for forecast', () => {
interface ForecastState {
predictions: ForecastPrediction
+ predictionsByCurve: Record
}
interface ForcastAction {
@@ -21,8 +22,8 @@ describe('Test redux reducer for forecast', () => {
let initState: ForecastState
beforeEach(() => {
- forecastState = { predictions: { outline: {}, output: { result: [] }, } }
- initState = { predictions: { outline: {}, output: { result: [] }, } }
+ forecastState = { predictions: { outline: {}, output: { result: [] }, }, predictionsByCurve: {} }
+ initState = { predictions: { outline: {}, output: { result: [] }, }, predictionsByCurve: {} }
action = { type: "", payload: null }
})
@@ -41,16 +42,25 @@ describe('Test redux reducer for forecast', () => {
})
it('Init with payload', () => {
- const payload: ForecastPrediction = { outline: {}, output: {} }
+ const payload: any = {
+ predictions: { outline: {}, output: {} },
+ curveIdx: 1,
+ }
action.payload = payload
const newState = forecastReducer(forecastState, action)
- expect(newState).toEqual(payload)
+ expect(newState).toEqual({
+ ...forecastState,
+ predictions: payload.predictions,
+ predictionsByCurve: {
+ 1: payload.predictions,
+ },
+ })
})
})
describe('Clear and reset', () => {
beforeEach(() => {
- forecastState = { predictions: { outline: null, output: null }}
+ forecastState = { predictions: { outline: null, output: null }, predictionsByCurve: {} }
})
it('Clear status', () => {
@@ -63,7 +73,7 @@ describe('Test redux reducer for forecast', () => {
it('Reset status', () => {
action.type = MANAGER.RESETALL
const newState = forecastReducer(forecastState, action)
- expect(newState).toEqual(initState)
+ expect(newState).toEqual(forecastState)
})
})
diff --git a/src/components/cmd_bar/01_viewer.js b/src/components/cmd_bar/01_viewer.js
index d1dff1a2..b37f7ed4 100644
--- a/src/components/cmd_bar/01_viewer.js
+++ b/src/components/cmd_bar/01_viewer.js
@@ -12,6 +12,7 @@ import Tooltip from '@mui/material/Tooltip';
import { setUiViewerType } from '../../actions/ui';
import Cfg from '../../helpers/cfg';
+import Format from '../../helpers/format';
import { MuButton, commonStyle, focusStyle } from './common';
import { LIST_UI_VIEWER_TYPE } from '../../constants/list_ui';
@@ -73,7 +74,14 @@ const mapStateToProps = (state, props) => ( // eslint-disable-line
{
isfocusSpectrumSt: state.ui.viewer === LIST_UI_VIEWER_TYPE.SPECTRUM,
isfocusAnalysisSt: state.ui.viewer === LIST_UI_VIEWER_TYPE.ANALYSIS,
- hideCmdAnaViewerSt: Cfg.hideCmdAnaViewer(state.layout) || props.editorOnly,
+ hideCmdAnaViewerSt: Cfg.hideCmdAnaViewer(state.layout)
+ || (
+ props.editorOnly
+ && !(
+ Format.isNmrLayout(state.layout)
+ || Format.isIrLayout(state.layout)
+ )
+ ),
disableCmdAnaViewerSt: Cfg.btnCmdAnaViewer(state.layout),
}
);
diff --git a/src/components/cmd_bar/r04_submit.js b/src/components/cmd_bar/r04_submit.js
index f7acdf37..6215e8e8 100644
--- a/src/components/cmd_bar/r04_submit.js
+++ b/src/components/cmd_bar/r04_submit.js
@@ -212,7 +212,7 @@ const selectOperation = (name, operations, updateOperationAct) => {
const Submit = ({
operations, classes, feature, forecast, editorOnly, hideSwitch, disabled,
- isAscendSt, isIntensitySt, operationSt, decimalSt, isEmWaveSt,
+ isAscendSt, isIntensitySt, operationSt, decimalSt, isEmWaveSt, layoutSt,
toggleIsAscendAct, toggleIsIntensityAct,
updateOperationAct, updateDecimalAct,
}) => {
@@ -222,6 +222,11 @@ const Submit = ({
if (!operations || operations.length === 0) return null;
+ const allowPredictInEditorOnly = Format.is1HLayout(layoutSt)
+ || Format.is13CLayout(layoutSt)
+ || Format.isIrLayout(layoutSt);
+ const shouldShowPredict = !editorOnly || allowPredictInEditorOnly;
+
return (
{
@@ -240,14 +245,14 @@ const Submit = ({
)
}
{
- editorOnly
- ? null
- : (
+ shouldShowPredict
+ ? (
)
+ : null
}
{
operationSelect(
@@ -267,6 +272,7 @@ const Submit = ({
const mapStateToProps = (state, props) => ( // eslint-disable-line
{
+ layoutSt: state.layout,
isEmWaveSt: Format.isEmWaveLayout(state.layout),
isAscendSt: state.submit.isAscend,
isIntensitySt: state.submit.isIntensity,
@@ -293,6 +299,7 @@ Submit.propTypes = {
operationSt: PropTypes.object.isRequired,
hideSwitch: PropTypes.bool.isRequired,
disabled: PropTypes.bool.isRequired,
+ layoutSt: PropTypes.string.isRequired,
isAscendSt: PropTypes.bool.isRequired,
isIntensitySt: PropTypes.bool.isRequired,
isEmWaveSt: PropTypes.bool.isRequired,
diff --git a/src/components/cmd_bar/r05_submit_btn.js b/src/components/cmd_bar/r05_submit_btn.js
index c1c21491..d8685727 100644
--- a/src/components/cmd_bar/r05_submit_btn.js
+++ b/src/components/cmd_bar/r05_submit_btn.js
@@ -68,6 +68,19 @@ const BtnSubmit = ({
const thres = Convert2Thres(feature, thresSt);
const aucValues = extractAreaUnderCurve(allIntegrationSt, integrationSt, layoutSt);
const { dscMetaData } = metaSt;
+ const predictionsByCurve = forecastSt.predictionsByCurve || {};
+ const hasCurvePredictions = Object.prototype.hasOwnProperty.call(
+ predictionsByCurve,
+ curveSt.curveIdx,
+ );
+ const hasAnyCurvePredictions = Object.keys(predictionsByCurve).length > 0;
+ const emptyPredictions = { outline: {}, output: { result: [] } };
+ let activePredictions = forecastSt.predictions;
+ if (hasCurvePredictions) {
+ activePredictions = predictionsByCurve[curveSt.curveIdx];
+ } else if (hasAnyCurvePredictions) {
+ activePredictions = emptyPredictions;
+ }
if (!operation) return null;
@@ -82,7 +95,7 @@ const BtnSubmit = ({
color="primary"
onClick={onClickCb(
operation.value, peaksEdit, isAscend, isIntensity,
- scan, thres, layoutSt, shiftSt, forecastSt.predictions, decimalSt,
+ scan, thres, layoutSt, shiftSt, activePredictions, decimalSt,
integrationSt, multiplicitySt, allIntegrationSt, aucValues, waveLengthSt,
cyclicvoltaSt, curveSt, axesUnitsSt, detectorSt, dscMetaData,
)}
diff --git a/src/components/cmd_bar/r06_predict_btn.js b/src/components/cmd_bar/r06_predict_btn.js
index 18d4e3a1..7f6988fa 100644
--- a/src/components/cmd_bar/r06_predict_btn.js
+++ b/src/components/cmd_bar/r06_predict_btn.js
@@ -199,7 +199,7 @@ const renderBtnUnknown = (
const BtnPredict = ({
classes, feature, forecast,
layoutSt, simulationSt, editPeakSt, scanSt, shiftSt, thresSt,
- integrationSt, multiplicitySt,
+ integrationSt, multiplicitySt, forecastSt,
setUiViewerTypeAct, curveSt,
}) => {
const is13Cor1H = Format.is13CLayout(layoutSt) || Format.is1HLayout(layoutSt);
@@ -212,11 +212,21 @@ const BtnPredict = ({
const thres = Convert2Thres(feature, thresSt);
const simuCount = simulationSt.nmrSimPeaks.length;
const uniqCount = [...new Set(simulationSt.nmrSimPeaks)].length;
+ const { curveIdx } = curveSt;
+ const predictionsByCurve = (forecastSt && forecastSt.predictionsByCurve) || {};
+ const hasCurvePredictions = Object.prototype.hasOwnProperty.call(predictionsByCurve, curveIdx);
+ const hasAnyCurvePredictions = Object.keys(predictionsByCurve).length > 0;
+ const emptyPredictions = { outline: {}, output: { result: [] } };
+ let analysisPredictions = (forecastSt && forecastSt.predictions) || forecast.predictions;
+ if (hasCurvePredictions) {
+ analysisPredictions = predictionsByCurve[curveIdx];
+ } else if (hasAnyCurvePredictions) {
+ analysisPredictions = emptyPredictions;
+ }
let realCount = 0;
if (Format.is13CLayout(layoutSt)) {
realCount = carbonFeatures(peaksEdit, multiplicitySt).length;
} else {
- const { curveIdx } = curveSt;
const { multiplicities } = multiplicitySt;
const selectedMultiplicity = multiplicities[curveIdx];
const { stack } = selectedMultiplicity;
@@ -226,7 +236,7 @@ const BtnPredict = ({
if (is13Cor1H && simuCount === 0) {
const onClickUnknownCb = onClicUnknown(
feature, forecast, peaksEdit, layoutSt, scan, shiftSt, thres,
- forecast.predictions, integrationSt, multiplicitySt, curveSt,
+ analysisPredictions, integrationSt, multiplicitySt, curveSt,
);
return renderBtnUnknown(classes, onClickUnknownCb);
}
@@ -238,7 +248,7 @@ const BtnPredict = ({
? (
onClickReady(
forecast, peaksEdit, layoutSt, scan, shiftSt, thres,
- forecast.predictions, integrationSt, multiplicitySt, setUiViewerTypeAct, curveSt,
+ analysisPredictions, integrationSt, multiplicitySt, setUiViewerTypeAct, curveSt,
)
)
: onClickFail(layoutSt, simuCount, realCount);
@@ -263,6 +273,7 @@ const mapStateToProps = (state, props) => ( // eslint-disable-line
integrationSt: state.integration.present,
multiplicitySt: state.multiplicity.present,
curveSt: state.curve,
+ forecastSt: state.forecast,
}
);
@@ -284,6 +295,7 @@ BtnPredict.propTypes = {
thresSt: PropTypes.object.isRequired,
integrationSt: PropTypes.object.isRequired,
multiplicitySt: PropTypes.object.isRequired,
+ forecastSt: PropTypes.object.isRequired,
setUiViewerTypeAct: PropTypes.func.isRequired,
curveSt: PropTypes.object,
};
diff --git a/src/components/d3_line/index.js b/src/components/d3_line/index.js
index d42c2796..f8fdfbc2 100644
--- a/src/components/d3_line/index.js
+++ b/src/components/d3_line/index.js
@@ -42,7 +42,9 @@ class ViewerLine extends React.Component {
resetAllAct,
} = this.props;
drawDestroy(this.rootKlass);
- resetAllAct(feature);
+ if (!isHidden) {
+ resetAllAct(feature);
+ }
let xxLabel = xLabel;
let yyLabel = yLabel;
diff --git a/src/components/forecast/comps.js b/src/components/forecast/comps.js
index 3107119a..ad784b90 100644
--- a/src/components/forecast/comps.js
+++ b/src/components/forecast/comps.js
@@ -180,6 +180,7 @@ const SectionUnknown = () => (
);
const notToRenderAnalysis = (pds) => {
+ if (!pds) return ;
if (pds.running) return ;
if (!pds.outline || !pds.outline.code) return ;
@@ -193,8 +194,8 @@ const sectionSvg = (classes, predictions) => {
const renderMsg = notToRenderAnalysis(predictions);
if (renderMsg) return null;
- if (!predictions.output) return null;
- const targetSvg = predictions.output.result[0].svgs[0];
+ if (!predictions || !predictions.output || !predictions.output.result || !predictions.output.result[0]) return null;
+ const targetSvg = predictions.output.result[0].svgs && predictions.output.result[0].svgs[0];
if (!targetSvg) return ;
return (
{
const theStatus = ['accept', 'reject'].includes(status) ? status : '';
@@ -35,6 +35,7 @@ const baseSelectIrStatus = ({
sma, identity, value: e.target.value,
},
svgs: [],
+ curveIdx,
});
}}
>
@@ -53,7 +54,9 @@ const baseSelectIrStatus = ({
};
const bssMapStateToProps = (state, props) => ( // eslint-disable-line
- {}
+ {
+ curveIdx: state.curve.curveIdx,
+ }
);
const bssMapDispatchToProps = (dispatch) => (
@@ -66,6 +69,7 @@ baseSelectIrStatus.propTypes = {
sma: PropTypes.string.isRequired,
status: PropTypes.string,
identity: PropTypes.string.isRequired,
+ curveIdx: PropTypes.number.isRequired,
setIrStatusAct: PropTypes.func.isRequired,
};
diff --git a/src/components/forecast/ir_viewer.js b/src/components/forecast/ir_viewer.js
index 8c053caf..a6e3696a 100644
--- a/src/components/forecast/ir_viewer.js
+++ b/src/components/forecast/ir_viewer.js
@@ -60,7 +60,7 @@ const sectionTable = (classes, pds) => {
const renderMsg = notToRenderAnalysis(pds);
if (renderMsg) return renderMsg;
- if (!pds.output.result || !pds.output.result[0]) return null;
+ if (!pds || !pds.output || !pds.output.result || !pds.output.result[0]) return null;
const { fgs } = pds.output.result[0];
if (!fgs) return null;
@@ -81,26 +81,41 @@ const sectionTable = (classes, pds) => {
};
const IrViewer = ({ // eslint-disable-line
- classes, molecule, inputCb, forecastSt,
-}) => (
-
-
-
-
- { sectionSvg(classes, forecastSt.predictions) }
-
-
-
- { sectionTable(classes, forecastSt.predictions) }
+ classes, molecule, inputCb, forecastSt, curveSt,
+}) => {
+ const { curveIdx } = curveSt;
+ const predictionsByCurve = forecastSt.predictionsByCurve || {};
+ const hasCurvePredictions = Object.prototype.hasOwnProperty.call(predictionsByCurve, curveIdx);
+ const hasAnyCurvePredictions = Object.keys(predictionsByCurve).length > 0;
+ const emptyPredictions = { outline: {}, output: { result: [] } };
+ let activePredictions = forecastSt.predictions || emptyPredictions;
+ if (hasCurvePredictions) {
+ activePredictions = predictionsByCurve[curveIdx];
+ } else if (hasAnyCurvePredictions) {
+ activePredictions = emptyPredictions;
+ }
+
+ return (
+
+
+
+
+ { sectionSvg(classes, activePredictions) }
+
+
+
+ { sectionTable(classes, activePredictions) }
+
-
- { sectionInput(classes, molecule, inputCb) }
-
-
-
-
- { sectionSvg(classes, forecastSt.predictions) }
-
-
-
- { sectionTable(classes, forecastSt.predictions) }
+ classes, molecule, inputCb, forecastSt, curveSt,
+}) => {
+ const { curveIdx } = curveSt;
+ const predictionsByCurve = forecastSt.predictionsByCurve || {};
+ const hasCurvePredictions = Object.prototype.hasOwnProperty.call(predictionsByCurve, curveIdx);
+ const hasAnyCurvePredictions = Object.keys(predictionsByCurve).length > 0;
+ const emptyPredictions = { outline: {}, output: { result: [] } };
+ let activePredictions = forecastSt.predictions || emptyPredictions;
+ if (hasCurvePredictions) {
+ activePredictions = predictionsByCurve[curveIdx];
+ } else if (hasAnyCurvePredictions) {
+ activePredictions = emptyPredictions;
+ }
+
+ return (
+
+
+
+
+ { sectionSvg(classes, activePredictions) }
+
+
+
+ { sectionTable(classes, activePredictions) }
+
-
- { sectionInput(classes, molecule, inputCb) }
- { SectionReference(classes) }
-
diff --git a/src/components/multi_jcamps_viewer.js b/src/components/multi_jcamps_viewer.js
index d6ffd248..1f205dc7 100644
--- a/src/components/multi_jcamps_viewer.js
+++ b/src/components/multi_jcamps_viewer.js
@@ -12,12 +12,14 @@ import { withStyles } from '@mui/styles';
import PanelViewer from './panel/index';
import CmdBar from './cmd_bar/index';
import ViewerMulti from './d3_multi/index';
+import ForecastViewer from './forecast_viewer';
import { setAllCurves } from '../actions/curve';
import {
addNewCylicVoltaPairPeak, addCylicVoltaMaxPeak, addCylicVoltaMinPeak, addCylicVoltaPecker,
} from '../actions/cyclic_voltammetry';
import { LIST_LAYOUT } from '../constants/list_layout';
+import { LIST_UI_VIEWER_TYPE } from '../constants/list_ui';
import Format from '../helpers/format';
const styles = () => ({
@@ -56,6 +58,7 @@ class MultiJcampsViewer extends React.Component { // eslint-disable-line
classes, curveSt, operations, entityFileNames,
entities, userManualLink, molSvg, exactMass, layoutSt,
integrationSt, descriptions, canChangeDescription, onDescriptionChanged,
+ forecast, uiSt, cLabel,
} = this.props;
if (!entities || entities.length === 0) return (
);
@@ -66,25 +69,50 @@ class MultiJcampsViewer extends React.Component { // eslint-disable-line
const { feature, topic } = entity;
const { integrations } = integrationSt;
const currentIntegration = integrations[curveIdx];
+ const isNmr = Format.isNmrLayout(layoutSt);
+ const isIr = Format.isIrLayout(layoutSt);
+ const isUvvis = Format.isUvVisLayout(layoutSt) || Format.isHplcUvVisLayout(layoutSt);
+ const isXRD = Format.isXRDLayout(layoutSt);
+ const hasForecast = forecast && Object.keys(forecast).length > 0;
+ const showForecast = hasForecast && (isNmr || isIr || isUvvis || isXRD)
+ && uiSt.viewer === LIST_UI_VIEWER_TYPE.ANALYSIS;
+ const xLabel = feature.xUnit ? `X (${feature.xUnit})` : '';
+ const yLabel = feature.yUnit ? `Y (${feature.yUnit})` : '';
return (
-
+ {showForecast ? (
+
+ ) : (
+
+ )}
( // eslint-disable-line
entities: state.curve.listCurves,
layoutSt: state.layout,
integrationSt: state.integration.present,
+ uiSt: state.ui,
}
);
@@ -148,18 +177,20 @@ MultiJcampsViewer.propTypes = {
descriptions: PropTypes.array.isRequired,
canChangeDescription: PropTypes.bool.isRequired,
onDescriptionChanged: PropTypes.func,
+ forecast: PropTypes.object.isRequired,
+ uiSt: PropTypes.object.isRequired,
+ cLabel: PropTypes.string,
};
MultiJcampsViewer.defaultProps = {
multiEntities: [],
entityFileNames: [],
molSvg: '',
- cLabel: '',
- xLabel: '',
- yLabel: '',
entities: [],
descriptions: [],
canChangeDescription: false,
+ forecast: {},
+ cLabel: '',
};
export default compose(
diff --git a/src/index.js b/src/index.js
index c689ebed..12107439 100644
--- a/src/index.js
+++ b/src/index.js
@@ -23,6 +23,7 @@ import compareIr2Jcamp from './__tests__/fixtures/compare_ir_2_jcamp';
import ramanJcamp from './__tests__/fixtures/raman_jcamp';
import msJcamp from './__tests__/fixtures/ms_jcamp';
import nmrResult from './__tests__/fixtures/nmr_result';
+import nmrResultAlt from './__tests__/fixtures/nmr_result_alt';
import irResult from './__tests__/fixtures/ir_result';
import Phenylalanin from './__tests__/fixtures/phenylalanin';
import compareUvVisJcamp from './__tests__/fixtures/compare_uv_vis_jcamp';
@@ -253,7 +254,7 @@ class DemoWriteIr extends React.Component {
loadOthers() {
const { showOthers, typ } = this.state;
- const isIr = typ === 'ir';
+ const isIr = typ === 'ir' || typ === 'multi ir';
const isXRD = typ === 'xrd';
const others = showOthers ? (
isIr ? [compIr1Entity, compIr2Entity] : (
@@ -418,7 +419,7 @@ class DemoWriteIr extends React.Component {
predictOp({
multiplicity, curveSt,
}) {
- const { curveIdx } = curveSt;
+ const { curveIdx = 0 } = curveSt || {};
const { multiplicities } = multiplicity;
const selectedMultiplicity = multiplicities[curveIdx];
const { stack, shift } = selectedMultiplicity;
@@ -428,13 +429,16 @@ class DemoWriteIr extends React.Component {
})
// console.log(targets)
const { molecule, typ } = this.state;
- const predictions = { running: true };
+ const predictions = { running: true, curveIdx };
this.setState({ predictions });
// simulate fetching...
- const result = typ === 'ir' ? irResult : nmrResult;
+ const selectNmrResult = (idx) => (idx % 2 === 0 ? nmrResult : nmrResultAlt);
+ const result = (typ === 'ir' || typ === 'multi ir')
+ ? irResult
+ : selectNmrResult(curveIdx);
setTimeout(() => {
- this.setState({ predictions: result });
+ this.setState({ predictions: { ...result, curveIdx } });
}, 2000);
}
diff --git a/src/layer_init.js b/src/layer_init.js
index 132877b9..f529ca7c 100644
--- a/src/layer_init.js
+++ b/src/layer_init.js
@@ -30,6 +30,7 @@ class LayerInit extends React.Component {
this.initReducer = this.initReducer.bind(this);
this.updateOthers = this.updateOthers.bind(this);
this.updateMultiEntities = this.updateMultiEntities.bind(this);
+ this.hasSameMultiEntities = this.hasSameMultiEntities.bind(this);
}
componentDidMount() {
@@ -42,7 +43,12 @@ class LayerInit extends React.Component {
componentDidUpdate(prevProps) {
this.normChange(prevProps);
this.updateOthers();
- this.updateMultiEntities();
+ const { entity, multiEntities } = this.props;
+ const multiEntitiesChanged = !this.hasSameMultiEntities(prevProps.multiEntities, multiEntities);
+ const entityChanged = prevProps.entity !== entity;
+ if (multiEntitiesChanged || entityChanged) {
+ this.updateMultiEntities();
+ }
}
normChange(prevProps) {
@@ -97,9 +103,36 @@ class LayerInit extends React.Component {
addOthersAct(others);
}
+ hasSameMultiEntities(prevMultiEntities, nextMultiEntities) {
+ if (prevMultiEntities === nextMultiEntities) return true;
+ const prevArray = Array.isArray(prevMultiEntities) ? prevMultiEntities : null;
+ const nextArray = Array.isArray(nextMultiEntities) ? nextMultiEntities : null;
+ if (!prevArray && !nextArray) return true;
+ if (!prevArray || !nextArray) return false;
+ if (prevArray.length !== nextArray.length) return false;
+ for (let idx = 0; idx < prevArray.length; idx += 1) {
+ if (prevArray[idx] !== nextArray[idx]) return false;
+ }
+ return true;
+ }
+
updateMultiEntities() {
- const { multiEntities, setAllCurvesAct } = this.props;
- setAllCurvesAct(multiEntities);
+ const { multiEntities, setAllCurvesAct, entity } = this.props;
+ const isMultiSpectra = Array.isArray(multiEntities) && multiEntities.length > 1;
+ if (isMultiSpectra) {
+ setAllCurvesAct(multiEntities);
+ return;
+ }
+
+ if (Format.isCyclicVoltaLayout(entity.layout)) {
+ const payload = (Array.isArray(multiEntities) && multiEntities.length > 0)
+ ? multiEntities
+ : [entity];
+ setAllCurvesAct(payload);
+ return;
+ }
+
+ setAllCurvesAct(false);
}
render() {
@@ -116,7 +149,8 @@ class LayerInit extends React.Component {
const xxLabel = !xLabel && xLabel === '' ? `X (${target.xUnit})` : xLabel;
const yyLabel = !yLabel && yLabel === '' ? `Y (${target.yUnit})` : yLabel;
- if (multiEntities) {
+ const isMultiSpectra = Array.isArray(multiEntities) && multiEntities.length > 1;
+ if (isMultiSpectra) {
return (
{
const {
topic, feature, hasEdit, integration, multiplicity,
} = extractParams(entity, { isEdit: true });
+ const simulation = entity && entity.features ? entity.features.simulation : undefined;
// const layout = entity.layout;
const { layout } = entity;
const maxminPeak = Convert2MaxMinPeak(layout, feature, 0);
const color = Format.mutiEntitiesColors(idx);
return {
- layout, topic, feature, hasEdit, integration, multiplicity, maxminPeak, color, curveIdx: idx,
+ layout,
+ topic,
+ feature,
+ hasEdit,
+ integration,
+ multiplicity,
+ simulation,
+ maxminPeak,
+ color,
+ curveIdx: idx,
};
});
diff --git a/src/reducers/reducer_forecast.js b/src/reducers/reducer_forecast.js
index fb1e135e..397860a9 100644
--- a/src/reducers/reducer_forecast.js
+++ b/src/reducers/reducer_forecast.js
@@ -6,8 +6,17 @@ const initialState = {
outline: {},
output: { result: [] },
},
+ predictionsByCurve: {},
};
+const toCurveIdx = (input) => (Number.isInteger(input) ? input : 0);
+
+const getPredictionsByCurve = (state) => (state.predictionsByCurve || {});
+
+const getPredictionsForCurve = (state, curveIdx) => (
+ getPredictionsByCurve(state)[curveIdx] || state.predictions
+);
+
const updateIrResl = (stResl, plPred) => {
const { sma, identity, value } = plPred;
const { svgs } = stResl;
@@ -24,21 +33,30 @@ const updateIrResl = (stResl, plPred) => {
};
const updateIrStatus = (state, action) => {
- const { predictions } = action.payload;
- const { outline, output } = state.predictions;
+ const { predictions, curveIdx } = action.payload;
+ const targetIdx = toCurveIdx(curveIdx);
+ const targetPredictions = getPredictionsForCurve(state, targetIdx);
+ const { outline, output } = targetPredictions;
const stResl = output.result[0];
const nextResl = updateIrResl(stResl, predictions);
+ const nextPredictions = {
+ outline,
+ output: {
+ result: [nextResl],
+ },
+ };
+ const predictionsByCurve = Object.assign(
+ {},
+ getPredictionsByCurve(state),
+ { [targetIdx]: nextPredictions },
+ );
return Object.assign(
{},
state,
{
- predictions: {
- outline,
- output: {
- result: [nextResl],
- },
- },
+ predictions: nextPredictions,
+ predictionsByCurve,
},
);
};
@@ -64,41 +82,68 @@ const updateNmrResl = (stResl, plPred) => {
};
const updateNmrStatus = (state, action) => {
- const { predictions } = action.payload;
- const { outline, output } = state.predictions;
+ const { predictions, curveIdx } = action.payload;
+ const targetIdx = toCurveIdx(curveIdx);
+ const targetPredictions = getPredictionsForCurve(state, targetIdx);
+ const { outline, output } = targetPredictions;
const stResl = output.result[0];
const nextResl = updateNmrResl(stResl, predictions);
+ const nextPredictions = {
+ outline,
+ output: {
+ result: [nextResl],
+ },
+ };
+ const predictionsByCurve = Object.assign(
+ {},
+ getPredictionsByCurve(state),
+ { [targetIdx]: nextPredictions },
+ );
- const newSt = Object.assign(
+ return Object.assign(
{},
state,
{
- predictions: {
- outline,
- output: {
- result: [nextResl],
- },
- },
+ predictions: nextPredictions,
+ predictionsByCurve,
},
);
- return newSt;
};
const forecastReducer = (state = initialState, action) => {
switch (action.type) {
case FORECAST.INIT_STATUS:
if (!action.payload) return state;
- return Object.assign(
- {},
- action.payload,
- );
+ {
+ const { curveIdx, ...payloadRest } = action.payload;
+ const nextPredictions = payloadRest.predictions || state.predictions;
+ const nextState = Object.assign(
+ {},
+ state,
+ payloadRest,
+ { predictions: nextPredictions },
+ );
+ if (!Number.isInteger(curveIdx)) {
+ return nextState;
+ }
+ const predictionsByCurve = Object.assign(
+ {},
+ getPredictionsByCurve(state),
+ nextPredictions ? { [curveIdx]: nextPredictions } : {},
+ );
+ return Object.assign({}, nextState, { predictionsByCurve });
+ }
case FORECAST.SET_IR_STATUS:
return updateIrStatus(state, action);
case FORECAST.SET_NMR_STATUS:
return updateNmrStatus(state, action);
case FORECAST.CLEAR_STATUS:
- case MANAGER.RESETALL:
return initialState;
+ case MANAGER.RESETALL:
+ if (action.payload && action.payload.resetForecast) {
+ return initialState;
+ }
+ return state;
default:
return state;
}
diff --git a/src/sagas/saga_multi_entities.js b/src/sagas/saga_multi_entities.js
index 8984b128..88fd6d36 100644
--- a/src/sagas/saga_multi_entities.js
+++ b/src/sagas/saga_multi_entities.js
@@ -6,6 +6,7 @@ import {
} from '../constants/action_type';
import { LIST_LAYOUT } from '../constants/list_layout';
+import Format from '../helpers/format';
const getLayoutSt = (state) => state.layout;
const getCurveSt = (state) => state.curve;
@@ -139,9 +140,34 @@ function* setInitIntegrations(action) { // eslint-disable-line
}
}
+function* setSimulationForCurve(action) { // eslint-disable-line
+ const layoutSt = yield select(getLayoutSt);
+ if (!Format.isNmrLayout(layoutSt)) return;
+
+ const curveSt = yield select(getCurveSt);
+ const { listCurves, curveIdx } = curveSt;
+ if (!Array.isArray(listCurves) || listCurves.length === 0) return;
+
+ const targetIdx = Number.isInteger(action.payload) ? action.payload : curveIdx;
+ const targetCurve = listCurves[targetIdx];
+ if (!targetCurve || !targetCurve.simulation) {
+ yield put({
+ type: SIMULATION.RESET_ALL_RDC,
+ payload: { nmrSimPeaks: [] },
+ });
+ return;
+ }
+
+ yield put({
+ type: SIMULATION.RESET_ALL_RDC,
+ payload: targetCurve.simulation,
+ });
+}
+
const multiEntitiesSagas = [
takeEvery(CURVE.SET_ALL_CURVES, setCyclicVoltametry),
takeEvery(CURVE.SET_ALL_CURVES, setInitIntegrations),
+ takeEvery(CURVE.SELECT_WORKING_CURVE, setSimulationForCurve),
takeEvery(CYCLIC_VOLTA_METRY.SET_FACTOR, setCyclicVoltametryRef),
];