+
x: ${_format.default.fixDigit(d.x, digits)}
+
+
y: ${d3.format('.2~e')(d.y * (yFactor || 1))}
+
+ `;
+const InitTip = () => {
+ d3.select('.peak-tp').remove();
+ const tip = (0, _d3Tip.default)().attr('class', 'd3-tip').html(({
+ d,
+ layout,
+ yFactor
+ }) => tpDiv(d, _format.default.spectraDigit(layout), yFactor || 1));
+ 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..53dfdc96
--- /dev/null
+++ b/dist/helpers/integration.js
@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.getLinearBaseline = exports.getIntegrationPoints = 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 getIntegrationPoints = (xL, xU, data) => data.filter(d => d && Number.isFinite(d.x) && Number.isFinite(d.y) && d.x > xL && d.x < xU);
+exports.getIntegrationPoints = getIntegrationPoints;
+const getLinearBaseline = points => {
+ if (!points || !points[0]) return () => 0;
+ const point1 = points[0];
+ const point2 = points[points.length - 1];
+ const slope = (0, _calc.calcSlope)(point1.x, point1.y, point2.x, point2.y);
+ return point => point1.y + slope * (point.x - point1.x);
+};
+exports.getLinearBaseline = getLinearBaseline;
+const getAbsoluteArea = (xL, xU, data) => {
+ const ps = getIntegrationPoints(xL, xU, data);
+ if (ps.length < 2) return 0;
+ const baselineY = getLinearBaseline(ps);
+ let area = 0;
+ if (ps.length > 1) {
+ for (let i = 1; i < ps.length; i += 1) {
+ const pt = ps[i];
+ const delta = Math.abs(pt.y - baselineY(pt));
+ area += delta;
+ }
+ }
+ return area;
+};
+exports.getAbsoluteArea = getAbsoluteArea;
+const calcArea = (d, refArea, refFactor, ignoreRef = false) => {
+ if (ignoreRef) {
+ const {
+ absoluteArea
+ } = d;
+ return !absoluteArea ? 0 : d.absoluteArea.toFixed(2);
+ }
+ return (d.area * refFactor / refArea).toFixed(2);
+};
+
+// eslint-disable-line
+exports.calcArea = calcArea;
\ No newline at end of file
diff --git a/dist/helpers/integration_draft.js b/dist/helpers/integration_draft.js
new file mode 100644
index 00000000..7563cad8
--- /dev/null
+++ b/dist/helpers/integration_draft.js
@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.setPendingIntegrationDraft = exports.hasPendingIntegrationDraft = exports.forgetPendingIntegrationDraft = exports.confirmCancelPendingIntegration = exports.clearPendingIntegrationDraft = void 0;
+let pendingIntegrationDraft = null;
+const cancelMessage = 'You are currently creating an integration. Are you sure you want to cancel it?';
+const hasPendingIntegrationDraft = () => !!pendingIntegrationDraft;
+exports.hasPendingIntegrationDraft = hasPendingIntegrationDraft;
+const setPendingIntegrationDraft = draft => {
+ pendingIntegrationDraft = draft;
+};
+exports.setPendingIntegrationDraft = setPendingIntegrationDraft;
+const forgetPendingIntegrationDraft = () => {
+ pendingIntegrationDraft = null;
+};
+exports.forgetPendingIntegrationDraft = forgetPendingIntegrationDraft;
+const clearPendingIntegrationDraft = () => {
+ const draft = pendingIntegrationDraft;
+ pendingIntegrationDraft = null;
+ if (draft && typeof draft.cancel === 'function') {
+ draft.cancel();
+ }
+};
+exports.clearPendingIntegrationDraft = clearPendingIntegrationDraft;
+const confirmCancelPendingIntegration = () => {
+ if (!hasPendingIntegrationDraft()) return true;
+ const shouldCancel = typeof window === 'undefined' || typeof window.confirm !== 'function'
+ // This confirmation intentionally protects an in-progress two-click integration.
+ // eslint-disable-next-line no-alert
+ || window.confirm(cancelMessage);
+ if (shouldCancel) {
+ clearPendingIntegrationDraft();
+ }
+ return shouldCancel;
+};
+exports.confirmCancelPendingIntegration = confirmCancelPendingIntegration;
\ No newline at end of file
diff --git a/dist/helpers/integration_split.js b/dist/helpers/integration_split.js
new file mode 100644
index 00000000..dc245c74
--- /dev/null
+++ b/dist/helpers/integration_split.js
@@ -0,0 +1,96 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.resolveSplitPreviewExtent = exports.interpolateY = exports.getSplitXFromEvent = exports.getIntegrationSplitTargetFromEvent = exports.getIntegrationSplitTarget = exports.getIntegrationBounds = exports.drawIntegrationSplitPreview = exports.clearIntegrationSplitPreview = exports.NMR_SPLIT_PREVIEW_EXTENT = void 0;
+var _integration = require("./integration");
+const d3 = require('d3');
+const SPLIT_PREVIEW_CLASS = 'integration-split-preview-line';
+const NMR_SPLIT_PREVIEW_EXTENT = exports.NMR_SPLIT_PREVIEW_EXTENT = {
+ y1: 38,
+ y2: 55
+};
+const getIntegrationBounds = (target, shift = 0) => [target.xL - shift, target.xU - shift].sort((a, b) => a - b);
+exports.getIntegrationBounds = getIntegrationBounds;
+const getSplitXFromEvent = (event, focus) => {
+ const rawMouseX = d3.pointer(event, focus.root.node())[0];
+ return focus.scales.x.invert(rawMouseX);
+};
+exports.getSplitXFromEvent = getSplitXFromEvent;
+const clearIntegrationSplitPreview = focus => {
+ if (!focus || !focus.root) return;
+ focus.root.select(`.${SPLIT_PREVIEW_CLASS}`).remove();
+};
+exports.clearIntegrationSplitPreview = clearIntegrationSplitPreview;
+const getIntegrationSplitTarget = (focus, splitX) => {
+ const splitTargets = focus && focus.integrationSplitTargets;
+ if (!splitTargets || !Number.isFinite(splitX)) return null;
+ const {
+ stack = [],
+ shift = 0
+ } = splitTargets;
+ return stack.find(target => {
+ const [xL, xU] = getIntegrationBounds(target, shift);
+ return splitX > xL && splitX < xU;
+ });
+};
+exports.getIntegrationSplitTarget = getIntegrationSplitTarget;
+const getIntegrationSplitTargetFromEvent = (event, focus) => {
+ const splitX = getSplitXFromEvent(event, focus);
+ const target = getIntegrationSplitTarget(focus, splitX);
+ return {
+ splitX,
+ target
+ };
+};
+exports.getIntegrationSplitTargetFromEvent = getIntegrationSplitTargetFromEvent;
+const interpolateY = (points, x) => {
+ if (!points || points.length === 0) return null;
+ const sortedPoints = [...points].sort((a, b) => a.x - b.x);
+ const upperIndex = sortedPoints.findIndex(point => point.x >= x);
+ if (upperIndex <= 0) return sortedPoints[0].y;
+ if (upperIndex < 0) return sortedPoints[sortedPoints.length - 1].y;
+ const lowerPoint = sortedPoints[upperIndex - 1];
+ const upperPoint = sortedPoints[upperIndex];
+ const xDelta = upperPoint.x - lowerPoint.x;
+ if (xDelta === 0) return lowerPoint.y;
+ const ratio = (x - lowerPoint.x) / xDelta;
+ return lowerPoint.y + ratio * (upperPoint.y - lowerPoint.y);
+};
+exports.interpolateY = interpolateY;
+const resolveSplitPreviewExtent = (focus, target, splitX, shift, ignoreRef) => {
+ if (!focus || !target || !focus.scales || !focus.scales.y) return null;
+ const yt = focus.scales.y;
+ const [xL, xU] = getIntegrationBounds(target, shift);
+ if (!Number.isFinite(splitX) || splitX <= xL || splitX >= xU) return null;
+ if (!ignoreRef) {
+ return NMR_SPLIT_PREVIEW_EXTENT;
+ }
+ const points = (0, _integration.getIntegrationPoints)(xL, xU, focus.data);
+ if (points.length < 2) return null;
+ const baselineY = (0, _integration.getLinearBaseline)(points);
+ const curveY = interpolateY(points, splitX);
+ if (!Number.isFinite(curveY)) return null;
+ return {
+ y1: yt(baselineY({
+ x: splitX
+ })),
+ y2: yt(curveY)
+ };
+};
+exports.resolveSplitPreviewExtent = resolveSplitPreviewExtent;
+const drawIntegrationSplitPreview = (focus, target, splitX, shift, ignoreRef) => {
+ const extent = resolveSplitPreviewExtent(focus, target, splitX, shift, ignoreRef);
+ if (!extent) {
+ clearIntegrationSplitPreview(focus);
+ return;
+ }
+ const xt = focus.scales.x;
+ const x = xt(splitX);
+ const preview = focus.root.select('.integration-preview');
+ preview.raise();
+ const line = preview.selectAll(`.${SPLIT_PREVIEW_CLASS}`).data([extent]);
+ line.enter().append('line').attr('class', SPLIT_PREVIEW_CLASS).attr('stroke', 'red').attr('stroke-width', 2).attr('stroke-dasharray', '4,3').style('pointer-events', 'none').merge(line).attr('x1', x).attr('x2', x).attr('y1', d => d.y1).attr('y2', d => d.y2);
+};
+exports.drawIntegrationSplitPreview = drawIntegrationSplitPreview;
\ No newline at end of file
diff --git a/dist/helpers/mount.js b/dist/helpers/mount.js
new file mode 100644
index 00000000..5f1bb693
--- /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 = (target, color, id, alpha = 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;
+};
+exports.MountComparePath = MountComparePath;
+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/sweep.js b/dist/helpers/sweep.js
new file mode 100644
index 00000000..b65f4519
--- /dev/null
+++ b/dist/helpers/sweep.js
@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.resolveVisibleYExtent = exports.buildSweepPayloadFromXBounds = void 0;
+const resolveVisibleYExtent = focus => {
+ const {
+ currentExtent,
+ h,
+ scales
+ } = focus;
+ if (currentExtent && currentExtent.yExtent) {
+ return currentExtent.yExtent;
+ }
+ const yes = [h, 0].map(scales.y.invert).sort((a, b) => a - b);
+ return {
+ yL: yes[0],
+ yU: yes[1]
+ };
+};
+exports.resolveVisibleYExtent = resolveVisibleYExtent;
+const buildSweepPayloadFromXBounds = (focus, xA, xB) => {
+ const {
+ data,
+ dataPks
+ } = focus;
+ const xes = [xA, xB].map(x => Number(x)).sort((a, b) => a - b);
+ return {
+ xExtent: {
+ xL: xes[0],
+ xU: xes[1]
+ },
+ yExtent: resolveVisibleYExtent(focus),
+ data,
+ dataPks
+ };
+};
+exports.buildSweepPayloadFromXBounds = buildSweepPayloadFromXBounds;
\ 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..88f8ad09
--- /dev/null
+++ b/dist/index.js
@@ -0,0 +1,877 @@
+"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 _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 pickSelectedSpectrumFromPayload = payload => {
+ const spectraList = payload?.spectra_list;
+ if (!Array.isArray(spectraList)) return payload || {};
+ if (spectraList.length === 0) return {};
+ const selectedIdx = Number.isFinite(payload?.curveSt?.curveIdx) ? payload.curveSt.curveIdx : 0;
+ return spectraList[selectedIdx] || spectraList[0] || {};
+};
+const normalizeShiftForFormatting = shift => {
+ if (shift && Array.isArray(shift.shifts)) return shift;
+ return {
+ selectedIdx: 0,
+ shifts: [shift || {
+ ref: {},
+ peak: false,
+ enable: true
+ }]
+ };
+};
+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';
+ 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({
+ peaks,
+ layout,
+ shift,
+ isAscend,
+ decimal,
+ isIntensity,
+ integration,
+ waveLength,
+ cyclicvoltaSt,
+ curveSt
+ }) {
+ const entity = this.loadEntity();
+ const safeLayout = layout || entity?.layout;
+ const {
+ features
+ } = entity;
+ const {
+ temperature
+ } = entity;
+ const {
+ maxY,
+ minY
+ } = Array.isArray(features) ? {} : features.editPeak || features.autoPeak;
+ const boundary = {
+ maxY,
+ minY
+ };
+ const shiftForFormatting = normalizeShiftForFormatting(shift);
+ const body = _app.FN.peaksBody({
+ peaks,
+ layout: safeLayout,
+ decimal,
+ shift: shiftForFormatting,
+ isAscend,
+ isIntensity,
+ boundary,
+ integration,
+ waveLength,
+ temperature
+ });
+ const wrapper = _app.FN.peaksWrapper(safeLayout, shiftForFormatting);
+ let desc = this.rmDollarSign(wrapper.head) + body + wrapper.tail;
+ if (_app.FN.isCyclicVoltaLayout(safeLayout) && cyclicvoltaSt?.spectraList && curveSt?.listCurves) {
+ const {
+ spectraList
+ } = cyclicvoltaSt;
+ const {
+ curveIdx,
+ listCurves
+ } = curveSt;
+ const selectedVolta = spectraList[curveIdx];
+ const selectedCurve = listCurves[curveIdx];
+ if (!selectedVolta || !selectedCurve?.feature) return desc;
+ 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({
+ multiplicity,
+ integration,
+ shift,
+ isAscend,
+ decimal,
+ layout
+ }) {
+ // 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 safeCenter = Number.isFinite(center) ? center : 0;
+ 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 hasValidRange = xs.length > 0 && Number.isFinite(shiftVal);
+ const mxA = mpyType === 'm' && hasValidRange ? (xs[aIdx] - shiftVal).toFixed(decimal) : safeCenter.toFixed(decimal);
+ const mxB = mpyType === 'm' && hasValidRange ? (xs[bIdx] - shiftVal).toFixed(decimal) : safeCenter.toFixed(decimal);
+ 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 shiftRef = shift?.ref || {};
+ const {
+ label,
+ value,
+ name
+ } = shiftRef;
+ const hasValidShiftRef = !!label && Number.isFinite(value) && typeof name === 'string';
+ const solvent = hasValidShiftRef ? `${name.split('(')[0].trim()} [${value.toFixed(decimal)} ppm], ` : '';
+ return `${layout} NMR (${freqStr}${solvent}ppm) δ = ${str}.`;
+ }
+ writeMpy(payload) {
+ const {
+ layout,
+ shift,
+ isAscend,
+ decimal,
+ multiplicity,
+ integration
+ } = pickSelectedSpectrumFromPayload(payload);
+ if (!_app.FN.isNmrLayout(layout)) return;
+ const desc = this.formatMpy({
+ multiplicity,
+ integration,
+ shift,
+ isAscend,
+ decimal,
+ layout
+ });
+ this.setState({
+ desc
+ });
+ }
+ writePeak(payload) {
+ const {
+ peaks,
+ layout,
+ shift,
+ isAscend,
+ decimal,
+ isIntensity,
+ integration,
+ waveLength,
+ cyclicvoltaSt,
+ curveSt
+ } = pickSelectedSpectrumFromPayload(payload);
+ const desc = this.formatPks({
+ peaks,
+ layout,
+ shift,
+ isAscend,
+ decimal,
+ isIntensity,
+ integration,
+ waveLength,
+ // eslint-disable-line
+ cyclicvoltaSt,
+ curveSt // eslint-disable-line
+ });
+ this.setState({
+ desc
+ });
+ }
+ savePeaks(payload) {
+ const {
+ peaks,
+ layout,
+ shift,
+ isAscend,
+ decimal,
+ analysis,
+ isIntensity,
+ integration,
+ multiplicity,
+ waveLength
+ } = pickSelectedSpectrumFromPayload(payload);
+ const entity = this.loadEntity();
+ const safeLayout = layout || entity?.layout;
+ const {
+ features
+ } = entity;
+ const {
+ temperature
+ } = entity;
+ const {
+ maxY,
+ minY
+ } = Array.isArray(features) ? features[0] : features.editPeak || features.autoPeak;
+ const boundary = {
+ maxY,
+ minY
+ };
+ const shiftForFormatting = normalizeShiftForFormatting(shift);
+ const body = _app.FN.peaksBody({
+ peaks,
+ layout: safeLayout,
+ decimal,
+ shift: shiftForFormatting,
+ 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({
+ multiplicity,
+ curveSt
+ }) {
+ const {
+ curveIdx
+ } = 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
+ };
+ this.setState({
+ predictions
+ });
+ // simulate fetching...
+ const result = typ === 'ir' ? _ir_result.default : _nmr_result.default;
+ setTimeout(() => {
+ this.setState({
+ predictions: result
+ });
+ }, 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..56a2fb51
--- /dev/null
+++ b/dist/layer_content.js
@@ -0,0 +1,104 @@
+"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 = ({
+ topic,
+ feature,
+ cLabel,
+ xLabel,
+ yLabel,
+ forecast,
+ operations,
+ layoutSt
+}) => {
+ 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..3df80431
--- /dev/null
+++ b/dist/layer_init.js
@@ -0,0 +1,256 @@
+"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);
+ }
+ componentDidMount() {
+ this.execReset();
+ this.initReducer();
+ this.updateOthers();
+ this.updateMultiEntities();
+ }
+ componentDidUpdate(prevProps) {
+ this.normChange(prevProps);
+ this.updateOthers();
+ 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);
+ }
+ 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,
+ 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,
+ 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..7680524a
--- /dev/null
+++ b/dist/layer_prism.js
@@ -0,0 +1,150 @@
+"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 = ({
+ entity,
+ cLabel,
+ xLabel,
+ yLabel,
+ forecast,
+ operations,
+ descriptions,
+ molSvg,
+ editorOnly,
+ exactMass,
+ thresSt,
+ scanSt,
+ uiSt,
+ canChangeDescription,
+ onDescriptionChanged
+}) => {
+ 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..b9544a85
--- /dev/null
+++ b/dist/reducers/reducer_axes.js
@@ -0,0 +1,56 @@
+"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 = (state, payload, isYAxis = 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 = (state = initialState, action) => {
+ 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..91c11de1
--- /dev/null
+++ b/dist/reducers/reducer_curve.js
@@ -0,0 +1,78 @@
+"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 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,
+ maxminPeak,
+ color,
+ curveIdx: idx
+ };
+ });
+ return Object.assign({}, state, {
+ curveIdx: 0,
+ listCurves: entities
+ });
+ }
+ return Object.assign({}, state, {
+ curveIdx: 0,
+ listCurves: payload
+ });
+};
+const curveReducer = (state = initialState, action) => {
+ 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..203cf350
--- /dev/null
+++ b/dist/reducers/reducer_detector.js
@@ -0,0 +1,50 @@
+"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 = (state = initialState, action) => {
+ 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..35d38bff
--- /dev/null
+++ b/dist/reducers/reducer_edit_peak.js
@@ -0,0 +1,234 @@
+"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 = (state = initialState, action) => {
+ 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;
+ }
+};
+exports.editPeakReducer = editPeakReducer;
+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..7dcb6c05
--- /dev/null
+++ b/dist/reducers/reducer_forecast.js
@@ -0,0 +1,120 @@
+"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: []
+ }
+ }
+};
+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
+ } = action.payload;
+ const {
+ outline,
+ output
+ } = state.predictions;
+ const stResl = output.result[0];
+ const nextResl = updateIrResl(stResl, predictions);
+ return Object.assign({}, state, {
+ predictions: {
+ outline,
+ output: {
+ result: [nextResl]
+ }
+ }
+ });
+};
+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
+ } = action.payload;
+ const {
+ outline,
+ output
+ } = state.predictions;
+ const stResl = output.result[0];
+ const nextResl = updateNmrResl(stResl, predictions);
+ const newSt = Object.assign({}, state, {
+ predictions: {
+ outline,
+ output: {
+ result: [nextResl]
+ }
+ }
+ });
+ return newSt;
+};
+const forecastReducer = (state = initialState, action) => {
+ switch (action.type) {
+ case _action_type.FORECAST.INIT_STATUS:
+ if (!action.payload) return state;
+ return Object.assign({}, action.payload);
+ 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:
+ case _action_type.MANAGER.RESETALL:
+ return initialState;
+ 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..ce3daefe
--- /dev/null
+++ b/dist/reducers/reducer_integration.js
@@ -0,0 +1,298 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.integrationReducer = 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 (!Number.isFinite(xL) || !Number.isFinite(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 (Number.isFinite(xL) && Number.isFinite(xU)) {
+ [txL, txU] = [xL, xU];
+ } else if (xExtent) {
+ [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 hasEnoughDataResolution = (xL, xU, data) => {
+ const [lower, upper] = [xL, xU].sort((a, b) => a - b);
+ const points = data.filter(pt => pt && Number.isFinite(pt.x) && pt.x >= lower && pt.x <= upper);
+ if (points.length < 2) return false;
+ return points.some(pt => pt.x !== points[0].x);
+};
+const buildSplitStackItem = (xL, xU, data, shift) => {
+ const [lower, upper] = [xL, xU].sort((a, b) => a - b);
+ const area = (0, _integration.getArea)(lower, upper, data);
+ const absoluteArea = (0, _integration.getAbsoluteArea)(lower, upper, data);
+ return {
+ xL: lower + shift,
+ xU: upper + shift,
+ area,
+ absoluteArea
+ };
+};
+const splitStack = (state, action) => {
+ const {
+ curveIdx,
+ target,
+ splitX,
+ data
+ } = action.payload;
+ if (!Number.isFinite(curveIdx) || !target || !Array.isArray(data)) {
+ return state;
+ }
+ const {
+ integrations
+ } = state;
+ const selectedIntegration = integrations[curveIdx];
+ if (!selectedIntegration || selectedIntegration === false) {
+ return state;
+ }
+ const {
+ stack,
+ shift
+ } = selectedIntegration;
+ const targetIndex = stack.findIndex(item => item.xL === target.xL && item.xU === target.xU);
+ if (targetIndex < 0 || !Number.isFinite(splitX)) {
+ return state;
+ }
+ const original = stack[targetIndex];
+ const [xL, xU] = [original.xL - shift, original.xU - shift].sort((a, b) => a - b);
+ if (!Number.isFinite(xL) || !Number.isFinite(xU) || splitX <= xL || splitX >= xU) {
+ return state;
+ }
+ if (!hasEnoughDataResolution(xL, splitX, data) || !hasEnoughDataResolution(splitX, xU, data)) {
+ return state;
+ }
+ const leftIntegration = buildSplitStackItem(xL, splitX, data, shift);
+ const rightIntegration = buildSplitStackItem(splitX, xU, data, shift);
+ const newStack = [...stack.slice(0, targetIndex), leftIntegration, rightIntegration, ...stack.slice(targetIndex + 1)];
+ 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 = (state = initialState, action) => {
+ 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.SPLIT:
+ return splitStack(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;
+ }
+};
+exports.integrationReducer = integrationReducer;
+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..6c18ec0f
--- /dev/null
+++ b/dist/reducers/reducer_jcamp.js
@@ -0,0 +1,99 @@
+"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, {
+ others,
+ addOthersCb
+}) => {
+ 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 = (state = initialState, action) => {
+ 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..c264e570
--- /dev/null
+++ b/dist/reducers/reducer_layout.js
@@ -0,0 +1,22 @@
+"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 = (state = initialState, action) => {
+ 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..2de439dd
--- /dev/null
+++ b/dist/reducers/reducer_manager.js
@@ -0,0 +1,17 @@
+"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 = (state = initialState, action) => {
+ 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..3b92cb0e
--- /dev/null
+++ b/dist/reducers/reducer_meta.js
@@ -0,0 +1,40 @@
+"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 = (state = initialState, action) => {
+ 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..651182e1
--- /dev/null
+++ b/dist/reducers/reducer_multiplicity.js
@@ -0,0 +1,199 @@
+"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 = (state = initialState, action) => {
+ 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..99fe706b
--- /dev/null
+++ b/dist/reducers/reducer_scan.js
@@ -0,0 +1,46 @@
+"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 = (state = initialState, action) => {
+ 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..310ac7d8
--- /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 normalizeShiftName = input => (input || '').toString().normalize('NFKD').replace(/[^a-z0-9]+/gi, '').toLowerCase();
+
+// 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;
+ const normalizedName = normalizeShiftName(name);
+ let target = false;
+ const listShift = (0, _list_shift.getListShift)(layout);
+ listShift.forEach(l => {
+ if (normalizeShiftName(l.name) === normalizedName) {
+ 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 = (state = initialState, action) => {
+ 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..81d0df10
--- /dev/null
+++ b/dist/reducers/reducer_simulation.js
@@ -0,0 +1,25 @@
+"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 = (state = initialState, action) => {
+ 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..e14b5f7c
--- /dev/null
+++ b/dist/reducers/reducer_status.js
@@ -0,0 +1,45 @@
+"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 = (state = initialState, action) => {
+ 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..6fc47bf8
--- /dev/null
+++ b/dist/reducers/reducer_submit.js
@@ -0,0 +1,59 @@
+"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 = (state = initialState, action) => {
+ 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..7fc7f727
--- /dev/null
+++ b/dist/reducers/reducer_threshold.js
@@ -0,0 +1,222 @@
+"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 = (state = initialState, action) => {
+ 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..14b7533f
--- /dev/null
+++ b/dist/reducers/reducer_ui.js
@@ -0,0 +1,49 @@
+"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 = (state = initialState, action) => {
+ 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..dd9e7727
--- /dev/null
+++ b/dist/reducers/reducer_voltammetry.js
@@ -0,0 +1,603 @@
+"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: [],
+ areaValue: 1.0,
+ areaUnit: 'cm²',
+ useCurrentDensity: false
+};
+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 = (state, action, isMax = 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 = (state, action, isMax = 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 = (state = initialState, action) => {
+ 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: []
+ });
+ case _action_type.CYCLIC_VOLTA_METRY.SET_AREA_VALUE:
+ {
+ const {
+ value
+ } = action.payload;
+ if (value === '') {
+ return Object.assign({}, state, {
+ areaValue: ''
+ });
+ }
+ const areaValue = Number.isFinite(value) ? value : state.areaValue;
+ return Object.assign({}, state, {
+ areaValue
+ });
+ }
+ case _action_type.CYCLIC_VOLTA_METRY.SET_AREA_UNIT:
+ {
+ const {
+ unit
+ } = action.payload;
+ return Object.assign({}, state, {
+ areaUnit: unit
+ });
+ }
+ case _action_type.CYCLIC_VOLTA_METRY.TOGGLE_DENSITY:
+ {
+ return Object.assign({}, state, {
+ useCurrentDensity: !state.useCurrentDensity
+ });
+ }
+ 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..7c6de7ab
--- /dev/null
+++ b/dist/reducers/reducer_wavelength.js
@@ -0,0 +1,20 @@
+"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 = (state = initialState, action) => {
+ 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..122961e6
--- /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.SPLIT, _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..ee648abd
--- /dev/null
+++ b/dist/sagas/saga_multi_entities.js
@@ -0,0 +1,234 @@
+"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_layout = require("../constants/list_layout");
+/* 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;
+ }
+ const cvSt = yield (0, _effects.select)(state => state.cyclicvolta);
+ const {
+ feature
+ } = firstCurve;
+ if (feature) {
+ const {
+ weAreaValue,
+ weAreaUnit,
+ currentMode
+ } = feature;
+ if (typeof weAreaUnit === 'string' && weAreaUnit.length > 0) {
+ const unit = weAreaUnit.replace('^2', '²');
+ yield (0, _effects.put)({
+ type: _action_type.CYCLIC_VOLTA_METRY.SET_AREA_UNIT,
+ payload: {
+ unit
+ }
+ });
+ } else {
+ yield (0, _effects.put)({
+ type: _action_type.CYCLIC_VOLTA_METRY.SET_AREA_UNIT,
+ payload: {
+ unit: 'cm²'
+ }
+ });
+ }
+ if (weAreaValue !== undefined && weAreaValue !== null) {
+ let numeric = null;
+ if (typeof weAreaValue === 'string') {
+ const parsed = parseFloat(weAreaValue);
+ if (!Number.isNaN(parsed)) numeric = parsed;
+ } else if (Number.isFinite(weAreaValue)) {
+ numeric = weAreaValue;
+ }
+ if (Number.isFinite(numeric)) {
+ yield (0, _effects.put)({
+ type: _action_type.CYCLIC_VOLTA_METRY.SET_AREA_VALUE,
+ payload: {
+ value: numeric
+ }
+ });
+ } else {
+ yield (0, _effects.put)({
+ type: _action_type.CYCLIC_VOLTA_METRY.SET_AREA_VALUE,
+ payload: {
+ value: 1.0
+ }
+ });
+ }
+ }
+ if (typeof currentMode === 'string' && currentMode.length > 0) {
+ const wantDensity = currentMode.toUpperCase() === 'DENSITY';
+ if (!!cvSt.useCurrentDensity !== wantDensity) {
+ yield (0, _effects.put)({
+ type: _action_type.CYCLIC_VOLTA_METRY.TOGGLE_DENSITY,
+ payload: null
+ });
+ }
+ }
+ }
+ 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
+ });
+ }
+ }
+ }
+}
+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.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..56645954
--- /dev/null
+++ b/dist/sagas/saga_multiplicity.js
@@ -0,0 +1,378 @@
+"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 = (action, metaSt, mpySt, curveIdx = 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__/units/actions/integration.test.tsx b/src/__tests__/units/actions/integration.test.tsx
index 859f35ac..125af940 100644
--- a/src/__tests__/units/actions/integration.test.tsx
+++ b/src/__tests__/units/actions/integration.test.tsx
@@ -1,5 +1,10 @@
import {
- clearIntegrationAll, setIntegrationFkr, sweepIntegration,
+ addVisualSplitLine,
+ clearIntegrationAll,
+ removeVisualSplitLine,
+ setIntegrationFkr,
+ splitIntegration,
+ sweepIntegration,
} from "../../../actions/integration";
import { INTEGRATION } from "../../../constants/action_type";
@@ -23,4 +28,22 @@ describe('Test redux action for integrations', () => {
expect(type).toEqual(INTEGRATION.CLEAR_ALL)
expect(payload).toEqual(payloadToBeSent)
})
+
+ it('Split integration', () => {
+ const { type, payload } = splitIntegration(payloadToBeSent)
+ expect(type).toEqual(INTEGRATION.SPLIT)
+ expect(payload).toEqual(payloadToBeSent)
+ })
+
+ it('Add visual split line', () => {
+ const { type, payload } = addVisualSplitLine(payloadToBeSent)
+ expect(type).toEqual(INTEGRATION.ADD_VISUAL_SPLIT)
+ expect(payload).toEqual(payloadToBeSent)
+ })
+
+ it('Remove visual split line', () => {
+ const { type, payload } = removeVisualSplitLine(payloadToBeSent)
+ expect(type).toEqual(INTEGRATION.RM_VISUAL_SPLIT)
+ expect(payload).toEqual(payloadToBeSent)
+ })
})
diff --git a/src/__tests__/units/helpers/chem.test.tsx b/src/__tests__/units/helpers/chem.test.tsx
index 743fad87..1a801491 100644
--- a/src/__tests__/units/helpers/chem.test.tsx
+++ b/src/__tests__/units/helpers/chem.test.tsx
@@ -3,6 +3,7 @@ import {
ToFrequency, Convert2Scan, Convert2Thres, GetComparisons, Convert2DValue,
GetCyclicVoltaRatio, GetCyclicVoltaPeakSeparate, convertTopic,
Convert2MaxMinPeak, Feature2MaxMinPeak, GetCyclicVoltaShiftOffset, GetCyclicVoltaPreviousShift,
+ buildIntegFeature,
} from "../../../helpers/chem";
import nmr1HJcamp from "../../fixtures/nmr1h_jcamp";
import aifJcamp1 from "../../fixtures/aif_jcamp_1";
@@ -519,6 +520,82 @@ describe('Test for chem helper', () => {
})
})
+ describe('Test build integration feature with persistent visualSplitGroupId', () => {
+ const linearSpectra = [{ data: [{ x: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], y: [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0] }] }]
+ const buildJcamp = (records: Record) => ({
+ info: { ...records },
+ spectra: [{}],
+ })
+
+ it('returns integrations without groupId for legacy JCAMPs', () => {
+ const jcamp: any = buildJcamp({
+ $OBSERVEDINTEGRALS: '\n0, 10, 5, 5',
+ })
+ const feature = buildIntegFeature(jcamp, linearSpectra)
+ expect(feature.stack).toHaveLength(1)
+ expect(feature.stack[0]).toMatchObject({ xL: 0, xU: 10 })
+ expect(feature.stack[0].visualSplitGroupId).toBeUndefined()
+ })
+
+ it('attaches a visualSplitGroupId from the JCAMP record', () => {
+ const jcamp: any = buildJcamp({
+ $OBSERVEDINTEGRALS: '\n0, 4, 2, 2\n4, 10, 3, 3',
+ $OBSERVEDINTEGRALSGROUPS: '\n0, vsg-abc-1\n1, vsg-abc-1',
+ })
+ const feature = buildIntegFeature(jcamp, linearSpectra)
+ expect(feature.stack[0].visualSplitGroupId).toBe('vsg-abc-1')
+ expect(feature.stack[1].visualSplitGroupId).toBe('vsg-abc-1')
+ })
+
+ it('preserves alphanumeric and dash characters in the groupId token', () => {
+ const jcamp: any = buildJcamp({
+ $OBSERVEDINTEGRALS: '\n0, 10, 5, 5',
+ $OBSERVEDINTEGRALSGROUPS: '\n0, vsg-token_42-XYZ',
+ })
+ const feature = buildIntegFeature(jcamp, linearSpectra)
+ expect(feature.stack[0].visualSplitGroupId).toBe('vsg-token_42-XYZ')
+ })
+
+ it('ignores groupId rows pointing to non existing integrations', () => {
+ const jcamp: any = buildJcamp({
+ $OBSERVEDINTEGRALS: '\n0, 10, 5, 5',
+ $OBSERVEDINTEGRALSGROUPS: '\n5, vsg-orphan',
+ })
+ const feature = buildIntegFeature(jcamp, linearSpectra)
+ expect(feature.stack[0].visualSplitGroupId).toBeUndefined()
+ })
+
+ it('keeps the groupId after the area normalisation pass', () => {
+ const jcamp: any = buildJcamp({
+ $OBSERVEDINTEGRALS: '\n0, 10, 5, 5',
+ $OBSERVEDINTEGRALSGROUPS: '\n0, vsg-abc',
+ })
+ const feature = buildIntegFeature(jcamp, linearSpectra)
+ expect(feature.stack[0].visualSplitGroupId).toBe('vsg-abc')
+ expect(feature.stack[0].area).toBeDefined()
+ })
+
+ it('parses GROUPS records that have no leading newline (header-less convention)', () => {
+ const jcamp: any = buildJcamp({
+ $OBSERVEDINTEGRALS: '\n0, 4, 2, 2\n4, 10, 3, 3',
+ $OBSERVEDINTEGRALSGROUPS: '0, vsg-headerless\n1, vsg-headerless',
+ })
+ const feature = buildIntegFeature(jcamp, linearSpectra)
+ expect(feature.stack[0].visualSplitGroupId).toBe('vsg-headerless')
+ expect(feature.stack[1].visualSplitGroupId).toBe('vsg-headerless')
+ })
+
+ it('ignores an arbitrary header line and still maps all valid rows', () => {
+ const jcamp: any = buildJcamp({
+ $OBSERVEDINTEGRALS: '\n0, 4, 2, 2\n4, 10, 3, 3',
+ $OBSERVEDINTEGRALSGROUPS: ' (X Y)\n0, vsg-hdr\n1, vsg-hdr',
+ })
+ const feature = buildIntegFeature(jcamp, linearSpectra)
+ expect(feature.stack[0].visualSplitGroupId).toBe('vsg-hdr')
+ expect(feature.stack[1].visualSplitGroupId).toBe('vsg-hdr')
+ })
+ })
+
describe('Test get previous offset CV layout', () => {
const voltaData = {"spectraList":[{"list":[{"min":{"x":-1.5404,"y":-0.00000307144},"max":{"x":0.10003,"y":0.00000285434},"isRef":true,"e12":-0.720185,"pecker":{"x":0.380242,"y":0.00000164361}}],"selectedIdx":0,"isWorkMaxPeak":true,"jcampIdx":0,"shift":{"ref":{"min":{"x":-1.5404,"y":-0.00000307144},"max":{"x":0.10003,"y":0.00000285434},"isRef":true,"e12":-0.720185,"pecker":{"x":0.380242,"y":0.00000164361}},"val":0, "prevValue":0.5},"hasRefPeak":true},{"list":[{"min":{"x":-1.48904,"y":-0.000033747399999999995},"max":{"x":0.929483,"y":0.00023741},"isRef":true,"e12":-0.27977849999999993}],"selectedIdx":0,"isWorkMaxPeak":true,"jcampIdx":1,"shift":{"ref":{"min":{"x":-1.48904,"y":-0.000033747399999999995},"max":{"x":0.929483,"y":0.00023741},"isRef":true,"e12":-0.27977849999999993},"val":1.5}},{"list":[{"min":{"x":0.45977,"y":-0.000226347},"max":{"x":1.00943,"y":0.000371349},"isRef":false,"e12":0.7346}],"selectedIdx":0,"isWorkMaxPeak":true,"jcampIdx":2,"shift":{"ref":null,"val":0}}]}
const voltaDataNoRef = {"spectraList":[{"list":[{"min":{"x":-1.5404,"y":-0.00000307144},"max":{"x":0.10003,"y":0.00000285434},"isRef":false,"e12":-0.720185,"pecker":{"x":0.380242,"y":0.00000164361}}],"selectedIdx":0,"isWorkMaxPeak":true,"jcampIdx":0,"shift":{"ref":null,"val":0, "prevValue":0.5},"hasRefPeak":false},{"list":[{"min":{"x":-1.48904,"y":-0.000033747399999999995},"max":{"x":0.929483,"y":0.00023741},"isRef":true,"e12":-0.27977849999999993}],"selectedIdx":0,"isWorkMaxPeak":true,"jcampIdx":1,"shift":{"ref":null,"val":1.5}},{"list":[{"min":{"x":0.45977,"y":-0.000226347},"max":{"x":1.00943,"y":0.000371349},"isRef":false,"e12":0.7346}],"selectedIdx":0,"isWorkMaxPeak":true,"jcampIdx":2,"shift":{"ref":null,"val":0}}]}
diff --git a/src/__tests__/units/helpers/integration.test.tsx b/src/__tests__/units/helpers/integration.test.tsx
index 4a46892b..8c28da53 100644
--- a/src/__tests__/units/helpers/integration.test.tsx
+++ b/src/__tests__/units/helpers/integration.test.tsx
@@ -1,4 +1,18 @@
-import { calcArea, getAbsoluteArea, getArea } from "../../../helpers/integration";
+import {
+ buildSplitIntervals,
+ calcArea,
+ generateVisualSplitGroupId,
+ getAbsoluteArea,
+ getAbsoluteAreaWithBaseline,
+ getArea,
+ getIntegrationPoints,
+ getLinearBaseline,
+ getSplitAreas,
+ getVisualSplitGroupBoundaries,
+ getVisualSplitGroups,
+ normalizeSplitLines,
+ splitAreaProportionally,
+} from "../../../helpers/integration";
describe('Test helper for integration', () => {
describe('Test get area', () => {
@@ -25,6 +39,171 @@ describe('Test helper for integration', () => {
})
})
+ describe('Test AUC baseline', () => {
+ it('starts the baseline at the first integration point, not at y=0', () => {
+ const points = getIntegrationPoints(0, 3, [
+ {x: 1, y: 10},
+ {x: 2, y: 12},
+ ]);
+ const baselineY = getLinearBaseline(points);
+
+ expect(baselineY(points[0])).toEqual(points[0].y);
+ expect(baselineY(points[1])).toEqual(points[1].y);
+ })
+
+ it('uses a deterministic linear baseline for interior points', () => {
+ const points = getIntegrationPoints(0, 4, [
+ {x: 1, y: 10},
+ {x: 2, y: 14},
+ {x: 3, y: 12},
+ ]);
+ const baselineY = getLinearBaseline(points);
+
+ expect(baselineY(points[1])).toEqual(11);
+ })
+ })
+
+ describe('Test visual split areas', () => {
+ const splitData = [
+ {x: 1, y: 0, k: 1},
+ {x: 2, y: 4, k: 2},
+ {x: 3, y: 4, k: 3},
+ {x: 4, y: 4, k: 4},
+ {x: 5, y: 0, k: 5},
+ ];
+
+ it('builds sorted intervals from internal split lines only', () => {
+ expect(buildSplitIntervals(0, 10, [8, -1, 4, 11])).toEqual([
+ { xL: 0, xU: 4 },
+ { xL: 4, xU: 8 },
+ { xL: 8, xU: 10 },
+ ]);
+ })
+
+ it('calculates split areas with the global integration baseline', () => {
+ const mainPoints = getIntegrationPoints(0, 6, splitData);
+ const baselineY = getLinearBaseline(mainPoints);
+
+ expect(getAbsoluteAreaWithBaseline(2.5, 6, splitData, baselineY)).toEqual(4);
+ expect(getSplitAreas(0, 6, [2.5], splitData)).toEqual([
+ { xL: 0, xU: 2.5, area: 1, absoluteArea: 4 },
+ { xL: 2.5, xU: 6, area: 2, absoluteArea: 4 },
+ ]);
+ })
+ })
+
+ describe('Test visual split groups', () => {
+ it('returns no groups for an empty stack', () => {
+ expect(getVisualSplitGroups([])).toEqual([])
+ expect(getVisualSplitGroups(null as any)).toEqual([])
+ })
+
+ it('returns singleton groups for items without groupId', () => {
+ const stack = [
+ { xL: 0, xU: 4, area: 4, absoluteArea: 0 },
+ { xL: 5, xU: 9, area: 4, absoluteArea: 0 },
+ ]
+ const groups = getVisualSplitGroups(stack)
+ expect(groups).toHaveLength(2)
+ expect(groups[0].isMerged).toBe(false)
+ expect(groups[1].isMerged).toBe(false)
+ })
+
+ it('groups consecutive items sharing a visualSplitGroupId', () => {
+ const stack = [
+ { xL: 0, xU: 4, area: 4, absoluteArea: 0, visualSplitGroupId: 'g1' },
+ { xL: 4, xU: 7, area: 3, absoluteArea: 0, visualSplitGroupId: 'g1' },
+ { xL: 8, xU: 10, area: 2, absoluteArea: 0 },
+ ]
+ const groups = getVisualSplitGroups(stack)
+ expect(groups).toHaveLength(2)
+ expect(groups[0].items).toHaveLength(2)
+ expect(groups[0].xL).toEqual(0)
+ expect(groups[0].xU).toEqual(7)
+ expect(groups[0].isMerged).toBe(true)
+ expect(groups[1].isMerged).toBe(false)
+ })
+
+ it('treats non-consecutive items with the same id as separate groups', () => {
+ const stack = [
+ { xL: 0, xU: 3, area: 3, absoluteArea: 0, visualSplitGroupId: 'g1' },
+ { xL: 4, xU: 6, area: 2, absoluteArea: 0 },
+ { xL: 7, xU: 10, area: 3, absoluteArea: 0, visualSplitGroupId: 'g1' },
+ ]
+ const groups = getVisualSplitGroups(stack)
+ expect(groups).toHaveLength(3)
+ expect(groups[0].isMerged).toBe(false)
+ expect(groups[2].isMerged).toBe(false)
+ })
+
+ it('returns the internal boundaries between merged items', () => {
+ const stack = [
+ { xL: 0, xU: 4, area: 4, absoluteArea: 0, visualSplitGroupId: 'g1' },
+ { xL: 4, xU: 7, area: 3, absoluteArea: 0, visualSplitGroupId: 'g1' },
+ { xL: 7, xU: 10, area: 3, absoluteArea: 0, visualSplitGroupId: 'g1' },
+ ]
+ const groups = getVisualSplitGroups(stack)
+ expect(getVisualSplitGroupBoundaries(groups[0])).toEqual([4, 7])
+ })
+
+ it('returns no boundaries for non-merged groups', () => {
+ const groups = getVisualSplitGroups([{ xL: 0, xU: 4, area: 4, absoluteArea: 0 }])
+ expect(getVisualSplitGroupBoundaries(groups[0])).toEqual([])
+ })
+ })
+
+ describe('Test generate visual split group id', () => {
+ it('produces unique stable ids', () => {
+ const a = generateVisualSplitGroupId()
+ const b = generateVisualSplitGroupId()
+ expect(typeof a).toBe('string')
+ expect(a.startsWith('vsg-')).toBe(true)
+ expect(a).not.toEqual(b)
+ })
+ })
+
+ describe('Test normalize split lines', () => {
+ it('returns an empty array when value is missing or invalid', () => {
+ expect(normalizeSplitLines(undefined)).toEqual([])
+ expect(normalizeSplitLines(null as any)).toEqual([])
+ expect(normalizeSplitLines('foo' as any)).toEqual([])
+ expect(normalizeSplitLines([NaN, undefined, null, 'x'] as any)).toEqual([])
+ })
+
+ it('keeps finite values, deduplicates them and returns ascending order', () => {
+ expect(normalizeSplitLines([4, 2, 4, 1.5, NaN, '3' as any])).toEqual([1.5, 2, 3, 4])
+ })
+ })
+
+ describe('Test split area proportionally', () => {
+ it('preserves the original total exactly while keeping the data ratio', () => {
+ const result = splitAreaProportionally(300, 200, 40)
+ expect(result.left + result.right).toBeCloseTo(300, 9)
+ expect(result.left / result.right).toBeCloseTo(200 / 40, 9)
+ })
+
+ it('returns zeros when the original total is zero', () => {
+ expect(splitAreaProportionally(0, 10, 20)).toEqual({ left: 0, right: 0 })
+ })
+
+ it('splits evenly when the raw measurements cannot infer a proportion', () => {
+ expect(splitAreaProportionally(8, 0, 0)).toEqual({ left: 4, right: 4 })
+ })
+
+ it('handles a single non-zero side by giving all the mass to it', () => {
+ const result = splitAreaProportionally(10, 0, 4)
+ expect(result.left).toEqual(0)
+ expect(result.right).toEqual(10)
+ })
+
+ it('gracefully treats non finite inputs as zero', () => {
+ expect(splitAreaProportionally(NaN as any, 1, 1)).toEqual({ left: 0, right: 0 })
+ const result = splitAreaProportionally(10, NaN as any, 5)
+ expect(result.left).toEqual(0)
+ expect(result.right).toEqual(10)
+ })
+ })
+
describe('Test calculate area', () => {
it('Do not ignore ref', () => {
const data = { area: 0.5 }
diff --git a/src/__tests__/units/helpers/integration_draft.test.tsx b/src/__tests__/units/helpers/integration_draft.test.tsx
new file mode 100644
index 00000000..ab4cca80
--- /dev/null
+++ b/src/__tests__/units/helpers/integration_draft.test.tsx
@@ -0,0 +1,50 @@
+import {
+ clearPendingIntegrationDraft,
+ confirmCancelPendingIntegration,
+ forgetPendingIntegrationDraft,
+ hasPendingIntegrationDraft,
+ setPendingIntegrationDraft,
+} from "../../../helpers/integration_draft";
+
+describe('Test helper for pending integration draft', () => {
+ afterEach(() => {
+ jest.restoreAllMocks();
+ forgetPendingIntegrationDraft();
+ });
+
+ it('tracks pending draft state', () => {
+ expect(hasPendingIntegrationDraft()).toBe(false);
+
+ setPendingIntegrationDraft({});
+
+ expect(hasPendingIntegrationDraft()).toBe(true);
+ });
+
+ it('clears a draft and invokes its cancel callback', () => {
+ const cancel = jest.fn();
+ setPendingIntegrationDraft({ cancel });
+
+ clearPendingIntegrationDraft();
+
+ expect(cancel).toHaveBeenCalledTimes(1);
+ expect(hasPendingIntegrationDraft()).toBe(false);
+ });
+
+ it('keeps a draft when cancellation is refused', () => {
+ jest.spyOn(window, 'confirm').mockReturnValue(false);
+ setPendingIntegrationDraft({});
+
+ expect(confirmCancelPendingIntegration()).toBe(false);
+ expect(hasPendingIntegrationDraft()).toBe(true);
+ });
+
+ it('clears a draft when cancellation is accepted', () => {
+ const cancel = jest.fn();
+ jest.spyOn(window, 'confirm').mockReturnValue(true);
+ setPendingIntegrationDraft({ cancel });
+
+ expect(confirmCancelPendingIntegration()).toBe(true);
+ expect(cancel).toHaveBeenCalledTimes(1);
+ expect(hasPendingIntegrationDraft()).toBe(false);
+ });
+});
diff --git a/src/__tests__/units/helpers/integration_split.test.tsx b/src/__tests__/units/helpers/integration_split.test.tsx
new file mode 100644
index 00000000..7c9d4dc3
--- /dev/null
+++ b/src/__tests__/units/helpers/integration_split.test.tsx
@@ -0,0 +1,193 @@
+import {
+ NMR_SPLIT_PREVIEW_EXTENT,
+ getIntegrationBounds,
+ getIntegrationSplitTarget,
+ getVisualSplitLineAtX,
+ getVisualSplitLines,
+ interpolateY,
+ isAlreadyVisuallySplit,
+ isMergedVisualSplitGroup,
+ resolveSplitPreviewExtent,
+} from "../../../helpers/integration_split";
+
+describe('Test helper for integration split preview', () => {
+ const data = [
+ { x: 0, y: 0 },
+ { x: 2, y: 4 },
+ { x: 4, y: 2 },
+ { x: 6, y: 0 },
+ ];
+
+ it('resolves shifted integration bounds in data coordinates', () => {
+ expect(getIntegrationBounds({ xL: 1, xU: 7 }, 1)).toEqual([0, 6]);
+ });
+
+ it('finds a split target only when the x position is inside an integration', () => {
+ const focus = {
+ integrationSplitTargets: {
+ stack: [{ xL: 0, xU: 3 }, { xL: 5, xU: 8 }],
+ shift: 0,
+ },
+ };
+
+ expect(getIntegrationSplitTarget(focus, 2)).toEqual({ xL: 0, xU: 3 });
+ expect(getIntegrationSplitTarget(focus, 4)).toBeUndefined();
+ });
+
+ it('interpolates y values between neighbouring points', () => {
+ expect(interpolateY(data, 3)).toEqual(3);
+ });
+
+ it('resolves visual split boundaries from the stack groups in data coordinates', () => {
+ const stack = [
+ { xL: 1, xU: 4, visualSplitGroupId: 'g1' },
+ { xL: 4, xU: 6, visualSplitGroupId: 'g1' },
+ ];
+ expect(getVisualSplitLines(stack, 1)).toEqual([3]);
+ });
+
+ it('returns no visual split lines when no group is merged', () => {
+ const stack = [
+ { xL: 0, xU: 4 },
+ { xL: 4, xU: 6 },
+ ];
+ expect(getVisualSplitLines(stack, 0)).toEqual([]);
+ });
+
+ it('finds an existing visual split line by screen tolerance', () => {
+ const focus = {
+ scales: { x: (value: number) => value * 10 },
+ };
+ const stack = [
+ { xL: 0, xU: 3, visualSplitGroupId: 'g1' },
+ { xL: 3, xU: 6, visualSplitGroupId: 'g1' },
+ ];
+
+ expect(getVisualSplitLineAtX(focus, stack, 3.4, 0, 5)).toEqual(3);
+ expect(getVisualSplitLineAtX(focus, stack, 3.7, 0, 5)).toBeNull();
+ });
+
+ it('uses fixed NMR preview bounds and rejects edge positions', () => {
+ const focus = { scales: { y: (value: number) => value }, data };
+ const target = { xL: 0, xU: 6 };
+
+ expect(resolveSplitPreviewExtent(focus, target, 3, 0, false)).toEqual(NMR_SPLIT_PREVIEW_EXTENT);
+ expect(resolveSplitPreviewExtent(focus, target, 0, 0, false)).toBeNull();
+ });
+
+ describe('isAlreadyVisuallySplit', () => {
+ it('returns false for a pristine integration that has never been split', () => {
+ expect(isAlreadyVisuallySplit({ xL: 0, xU: 10 })).toBe(false);
+ });
+
+ it('returns true for a child stack item that carries a visualSplitGroupId', () => {
+ expect(isAlreadyVisuallySplit({ xL: 0, xU: 4, visualSplitGroupId: 'g1' })).toBe(true);
+ });
+
+ it('returns true for a merged group container exposed to the UI', () => {
+ expect(isAlreadyVisuallySplit({
+ xL: 0, xU: 10, isMerged: true, groupId: 'g1',
+ })).toBe(true);
+ });
+
+ it('returns false for a singleton group container', () => {
+ expect(isAlreadyVisuallySplit({
+ xL: 0, xU: 10, isMerged: false, groupId: null,
+ })).toBe(false);
+ });
+
+ it('returns false for nullish or empty input', () => {
+ expect(isAlreadyVisuallySplit(null as any)).toBe(false);
+ expect(isAlreadyVisuallySplit(undefined as any)).toBe(false);
+ });
+ });
+
+ describe('isMergedVisualSplitGroup', () => {
+ it('returns true only for a merged group container', () => {
+ expect(isMergedVisualSplitGroup({
+ xL: 0, xU: 10, isMerged: true, groupId: 'g1',
+ })).toBe(true);
+ });
+
+ it('returns false for a raw child stack item carrying a groupId', () => {
+ expect(isMergedVisualSplitGroup({ xL: 0, xU: 4, visualSplitGroupId: 'g1' })).toBe(false);
+ });
+
+ it('returns false for a pristine integration and for nullish input', () => {
+ expect(isMergedVisualSplitGroup({ xL: 0, xU: 10 })).toBe(false);
+ expect(isMergedVisualSplitGroup(null as any)).toBe(false);
+ expect(isMergedVisualSplitGroup(undefined as any)).toBe(false);
+ });
+ });
+
+ it('resolves HPLC preview bounds between baseline and curve', () => {
+ const focus = {
+ scales: { y: (value: number) => value },
+ data: [
+ { x: 0, y: 0 },
+ { x: 2, y: 4 },
+ { x: 3, y: 6 },
+ { x: 4, y: 4 },
+ { x: 6, y: 0 },
+ ],
+ };
+
+ const extent = resolveSplitPreviewExtent(focus, { xL: 0, xU: 6 }, 3, 0, true);
+
+ expect(extent).toEqual({ y1: 4, y2: 6 });
+ });
+
+ it('uses the merged group bounds for the baseline when previewing on a visual split child', () => {
+ const stack = [
+ { xL: 0, xU: 3, visualSplitGroupId: 'g1' },
+ { xL: 3, xU: 6, visualSplitGroupId: 'g1' },
+ ];
+ const focus: any = {
+ scales: { y: (value: number) => value },
+ data: [
+ { x: 0, y: 0 },
+ { x: 1, y: 2 },
+ { x: 2, y: 4 },
+ { x: 3, y: 6 },
+ { x: 4, y: 4 },
+ { x: 5, y: 2 },
+ { x: 6, y: 0 },
+ ],
+ integrationSplitTargets: { stack, shift: 0, ignoreRef: true },
+ };
+
+ const childExtent = resolveSplitPreviewExtent(focus, stack[1], 4, 0, true);
+ const groupExtent = resolveSplitPreviewExtent(
+ focus,
+ { xL: 0, xU: 6, isMerged: true },
+ 4,
+ 0,
+ true,
+ );
+
+ expect(childExtent).toEqual(groupExtent);
+ expect(childExtent).toEqual({ y1: 2, y2: 4 });
+ });
+
+ it('falls back to the local target bounds when no visual split context is available', () => {
+ const focus: any = {
+ scales: { y: (value: number) => value },
+ data: [
+ { x: 0, y: 10 },
+ { x: 1, y: 2 },
+ { x: 2, y: 4 },
+ { x: 3, y: 6 },
+ { x: 4, y: 4 },
+ { x: 5, y: 2 },
+ { x: 6, y: 10 },
+ ],
+ };
+
+ const targetOnly = resolveSplitPreviewExtent(focus, { xL: 1, xU: 5 }, 3, 0, true);
+ const fullData = resolveSplitPreviewExtent(focus, { xL: 0, xU: 6 }, 3, 0, true);
+
+ expect(targetOnly).not.toBeNull();
+ expect(fullData).not.toBeNull();
+ expect(targetOnly).not.toEqual(fullData);
+ });
+});
diff --git a/src/__tests__/units/helpers/sweep.test.tsx b/src/__tests__/units/helpers/sweep.test.tsx
new file mode 100644
index 00000000..3e2037a9
--- /dev/null
+++ b/src/__tests__/units/helpers/sweep.test.tsx
@@ -0,0 +1,42 @@
+import { buildSweepPayloadFromXBounds } from "../../../helpers/sweep";
+
+describe('Test helper for sweep payloads', () => {
+ const data = [{ x: 0, y: 1, k: 0 }, { x: 2, y: 2, k: 1 }];
+ const dataPks = [{ x: 1, y: 2 }];
+
+ it('builds the same integration sweep shape from two x bounds', () => {
+ const focus = {
+ data,
+ dataPks,
+ currentExtent: {
+ yExtent: { yL: -1, yU: 3 },
+ },
+ };
+
+ const payload = buildSweepPayloadFromXBounds(focus, 2, 0);
+
+ expect(payload).toEqual({
+ xExtent: { xL: 0, xU: 2 },
+ yExtent: { yL: -1, yU: 3 },
+ data,
+ dataPks,
+ });
+ });
+
+ it('accepts zero as a valid lower x bound', () => {
+ const focus = {
+ data,
+ dataPks,
+ h: 10,
+ scales: {
+ y: {
+ invert: (value) => value,
+ },
+ },
+ };
+
+ const payload = buildSweepPayloadFromXBounds(focus, 0, 1);
+
+ expect(payload.xExtent).toEqual({ xL: 0, xU: 1 });
+ });
+});
diff --git a/src/__tests__/units/reducers/reducer_integration.test.tsx b/src/__tests__/units/reducers/reducer_integration.test.tsx
new file mode 100644
index 00000000..602d30e0
--- /dev/null
+++ b/src/__tests__/units/reducers/reducer_integration.test.tsx
@@ -0,0 +1,840 @@
+import { INTEGRATION } from "../../../constants/action_type";
+import undoableIntegrationReducer, { integrationReducer } from "../../../reducers/reducer_integration";
+import { ActionCreators, newHistory } from "redux-undo";
+
+describe('Test redux reducer for integrations', () => {
+ const data = [
+ { x: 0, y: 0, k: 0 },
+ { x: 2, y: 3, k: 2 },
+ { x: 4, y: 4, k: 4 },
+ { x: 6, y: 2, k: 6 },
+ { x: 8, y: 1, k: 8 },
+ { x: 10, y: 0, k: 10 },
+ ];
+
+ it('splits one integration into two calculated integrations atomically', () => {
+ const state: any = {
+ selectedIdx: 0,
+ integrations: [{
+ stack: [{ xL: 0, xU: 10, area: 10, absoluteArea: 0 }],
+ refArea: 10,
+ refFactor: 2,
+ shift: 0,
+ edited: false,
+ }],
+ };
+
+ const newState = integrationReducer(state, {
+ type: INTEGRATION.SPLIT,
+ payload: {
+ curveIdx: 0,
+ target: { xL: 0, xU: 10 },
+ splitX: 4,
+ data,
+ },
+ });
+
+ expect(newState.integrations[0].stack).toHaveLength(2);
+ expect(newState.integrations[0].stack[0]).toMatchObject({ xL: 0, xU: 4, area: 4 });
+ expect(newState.integrations[0].stack[1]).toMatchObject({ xL: 4, xU: 10, area: 6 });
+ expect(newState.integrations[0].refArea).toEqual(10);
+ expect(newState.integrations[0].refFactor).toEqual(2);
+ });
+
+ it('keeps shifted stored bounds while calculating with data coordinates', () => {
+ const state: any = {
+ selectedIdx: 0,
+ integrations: [{
+ stack: [{ xL: 1, xU: 11, area: 10, absoluteArea: 0 }],
+ refArea: 10,
+ refFactor: 1,
+ shift: 1,
+ edited: false,
+ }],
+ };
+
+ const newState = integrationReducer(state, {
+ type: INTEGRATION.SPLIT,
+ payload: {
+ curveIdx: 0,
+ target: { xL: 1, xU: 11 },
+ splitX: 4,
+ data,
+ },
+ });
+
+ expect(newState.integrations[0].stack[0]).toMatchObject({ xL: 1, xU: 5, area: 4 });
+ expect(newState.integrations[0].stack[1]).toMatchObject({ xL: 5, xU: 11, area: 6 });
+ });
+
+ it('rejects splits that do not leave enough data resolution on both sides', () => {
+ const state: any = {
+ selectedIdx: 0,
+ integrations: [{
+ stack: [{ xL: 0, xU: 10, area: 10, absoluteArea: 0 }],
+ refArea: 10,
+ refFactor: 1,
+ shift: 0,
+ edited: false,
+ }],
+ };
+
+ const newState = integrationReducer(state, {
+ type: INTEGRATION.SPLIT,
+ payload: {
+ curveIdx: 0,
+ target: { xL: 0, xU: 10 },
+ splitX: 1,
+ data,
+ },
+ });
+
+ expect(newState).toBe(state);
+ });
+
+ it('removes an integration whose lower x bound is zero', () => {
+ const state: any = {
+ selectedIdx: 0,
+ integrations: [{
+ stack: [
+ { xL: 0, xU: 10, area: 10, absoluteArea: 0 },
+ { xL: 12, xU: 14, area: 2, absoluteArea: 0 },
+ ],
+ refArea: 10,
+ refFactor: 1,
+ shift: 0,
+ edited: false,
+ }],
+ };
+
+ const newState = integrationReducer(state, {
+ type: INTEGRATION.RM_ONE,
+ payload: {
+ curveIdx: 0,
+ dataToRemove: { xL: 0, xU: 10 },
+ },
+ });
+
+ expect(newState.integrations[0].stack).toEqual([{ xL: 12, xU: 14, area: 2, absoluteArea: 0 }]);
+ });
+
+ it('undoes a split in one step', () => {
+ const state: any = {
+ selectedIdx: 0,
+ integrations: [{
+ stack: [{ xL: 0, xU: 10, area: 10, absoluteArea: 0 }],
+ refArea: 10,
+ refFactor: 1,
+ shift: 0,
+ edited: false,
+ }],
+ };
+ const splitPresent = integrationReducer(state, {
+ type: INTEGRATION.SPLIT,
+ payload: {
+ curveIdx: 0,
+ target: { xL: 0, xU: 10 },
+ splitX: 4,
+ data,
+ },
+ });
+ const splitState: any = newHistory([state], splitPresent, []);
+ const undoneState = undoableIntegrationReducer(splitState, ActionCreators.undo());
+
+ expect(splitState.present.integrations[0].stack).toHaveLength(2);
+ expect(undoneState.present.integrations[0].stack).toEqual(state.integrations[0].stack);
+ });
+
+ it('undoes the very first integration added after a fresh load', () => {
+ const freshPresent = {
+ selectedIdx: 0,
+ integrations: [{
+ stack: [],
+ refArea: 1,
+ refFactor: 1,
+ shift: 0,
+ edited: false,
+ }],
+ };
+ const fresh: any = newHistory([], freshPresent, []);
+
+ const afterAdd = undoableIntegrationReducer(fresh, {
+ type: 'UI_SWEEP_SELECT_INTEGRATION',
+ payload: {
+ curveIdx: 0,
+ newData: { xExtent: { xL: 2, xU: 8 }, data },
+ },
+ });
+
+ expect(afterAdd.past).toHaveLength(1);
+ expect(afterAdd.present.integrations[0].stack).toHaveLength(1);
+
+ const undone = undoableIntegrationReducer(afterAdd, ActionCreators.undo());
+ expect(undone.present.integrations[0].stack).toHaveLength(0);
+
+ const redone = undoableIntegrationReducer(undone, ActionCreators.redo());
+ expect(redone.present.integrations[0].stack).toHaveLength(1);
+ });
+
+ it('records a split in the undoable history when dispatched through the undoable reducer', () => {
+ const seed: any = {
+ selectedIdx: 0,
+ integrations: [{
+ stack: [{ xL: 0, xU: 10, area: 10, absoluteArea: 0 }],
+ refArea: 10,
+ refFactor: 1,
+ shift: 0,
+ edited: false,
+ }],
+ };
+ const seedHistory: any = newHistory([], seed, []);
+
+ const afterSplit = undoableIntegrationReducer(seedHistory, {
+ type: INTEGRATION.SPLIT,
+ payload: {
+ curveIdx: 0,
+ target: { xL: 0, xU: 10 },
+ splitX: 4,
+ data,
+ },
+ });
+
+ expect(afterSplit.past).toHaveLength(1);
+ expect(afterSplit.present.integrations[0].stack).toHaveLength(2);
+
+ const undone = undoableIntegrationReducer(afterSplit, ActionCreators.undo());
+ expect(undone.present.integrations[0].stack).toEqual(seed.integrations[0].stack);
+
+ const redone = undoableIntegrationReducer(undone, ActionCreators.redo());
+ expect(redone.present.integrations[0].stack).toEqual(afterSplit.present.integrations[0].stack);
+ });
+
+ it('adds a visual split line by splitting the target into two grouped stack items', () => {
+ const state: any = {
+ selectedIdx: 0,
+ integrations: [{
+ stack: [{ xL: 0, xU: 10, area: 10, absoluteArea: 0 }],
+ refArea: 10,
+ refFactor: 1,
+ shift: 0,
+ edited: false,
+ }],
+ };
+
+ const newState = integrationReducer(state, {
+ type: INTEGRATION.ADD_VISUAL_SPLIT,
+ payload: {
+ curveIdx: 0,
+ target: { xL: 0, xU: 10 },
+ splitX: 4,
+ data,
+ },
+ });
+
+ expect(newState.integrations[0].stack).toHaveLength(2);
+ expect(newState.integrations[0].stack[0]).toMatchObject({ xL: 0, xU: 4, area: 4 });
+ expect(newState.integrations[0].stack[1]).toMatchObject({ xL: 4, xU: 10, area: 6 });
+ const groupId = newState.integrations[0].stack[0].visualSplitGroupId;
+ expect(typeof groupId).toBe('string');
+ expect(newState.integrations[0].stack[1].visualSplitGroupId).toBe(groupId);
+ });
+
+ it('stores shifted visual split bounds consistently with the integration stack item', () => {
+ const state: any = {
+ selectedIdx: 0,
+ integrations: [{
+ stack: [{ xL: 1, xU: 11, area: 10, absoluteArea: 0 }],
+ refArea: 10,
+ refFactor: 1,
+ shift: 1,
+ edited: false,
+ }],
+ };
+
+ const newState = integrationReducer(state, {
+ type: INTEGRATION.ADD_VISUAL_SPLIT,
+ payload: {
+ curveIdx: 0,
+ target: { xL: 1, xU: 11 },
+ splitX: 4,
+ data,
+ },
+ });
+
+ expect(newState.integrations[0].stack[0]).toMatchObject({ xL: 1, xU: 5 });
+ expect(newState.integrations[0].stack[1]).toMatchObject({ xL: 5, xU: 11 });
+ expect(newState.integrations[0].stack[0].visualSplitGroupId)
+ .toBe(newState.integrations[0].stack[1].visualSplitGroupId);
+ });
+
+ it('rejects splitting a child item that already belongs to a visual split group', () => {
+ const state: any = {
+ selectedIdx: 0,
+ integrations: [{
+ stack: [
+ { xL: 0, xU: 6, area: 6, absoluteArea: 0, visualSplitGroupId: 'g1' },
+ { xL: 6, xU: 10, area: 4, absoluteArea: 0, visualSplitGroupId: 'g1' },
+ ],
+ refArea: 10,
+ refFactor: 1,
+ shift: 0,
+ edited: false,
+ }],
+ };
+
+ const newState = integrationReducer(state, {
+ type: INTEGRATION.ADD_VISUAL_SPLIT,
+ payload: {
+ curveIdx: 0,
+ target: { xL: 0, xU: 6 },
+ splitX: 4,
+ data,
+ },
+ });
+
+ expect(newState).toBe(state);
+ });
+
+ it('rejects a second visual split on a previously split integration restored from storage', () => {
+ const state: any = {
+ selectedIdx: 0,
+ integrations: [{
+ stack: [
+ { xL: 0, xU: 4, area: 4, absoluteArea: 0, visualSplitGroupId: 'persisted-vsg' },
+ { xL: 4, xU: 10, area: 6, absoluteArea: 0, visualSplitGroupId: 'persisted-vsg' },
+ ],
+ refArea: 10,
+ refFactor: 1,
+ shift: 0,
+ edited: false,
+ }],
+ };
+
+ const newState = integrationReducer(state, {
+ type: INTEGRATION.ADD_VISUAL_SPLIT,
+ payload: {
+ curveIdx: 0,
+ target: { xL: 4, xU: 10 },
+ splitX: 6,
+ data,
+ },
+ });
+
+ expect(newState).toBe(state);
+ });
+
+ it('preserves the original stored area when visually splitting a JCAMP-loaded integration', () => {
+ const state: any = {
+ selectedIdx: 0,
+ integrations: [{
+ stack: [{ xL: 0, xU: 10, area: 300, absoluteArea: 60 }],
+ refArea: 300,
+ refFactor: 1,
+ shift: 0,
+ edited: false,
+ }],
+ };
+
+ const newState = integrationReducer(state, {
+ type: INTEGRATION.ADD_VISUAL_SPLIT,
+ payload: {
+ curveIdx: 0,
+ target: { xL: 0, xU: 10 },
+ splitX: 4,
+ data,
+ },
+ });
+
+ const [leftChild, rightChild] = newState.integrations[0].stack;
+ expect(leftChild.area + rightChild.area).toBeCloseTo(300, 9);
+ expect(leftChild.absoluteArea + rightChild.absoluteArea).toBeCloseTo(60, 9);
+ expect(leftChild.area).toBeGreaterThan(0);
+ expect(rightChild.area).toBeGreaterThan(0);
+ });
+
+ it('recomputes each side from raw data on a regular split (independent integrations)', () => {
+ const state: any = {
+ selectedIdx: 0,
+ integrations: [{
+ stack: [{ xL: 0, xU: 10, area: 300, absoluteArea: 60 }],
+ refArea: 300,
+ refFactor: 1,
+ shift: 0,
+ edited: false,
+ }],
+ };
+
+ const newState = integrationReducer(state, {
+ type: INTEGRATION.SPLIT,
+ payload: {
+ curveIdx: 0,
+ target: { xL: 0, xU: 10 },
+ splitX: 4,
+ data,
+ },
+ });
+
+ const [leftChild, rightChild] = newState.integrations[0].stack;
+ expect(leftChild).toMatchObject({ xL: 0, xU: 4, area: 4 });
+ expect(rightChild).toMatchObject({ xL: 4, xU: 10, area: 6 });
+ expect(leftChild.area + rightChild.area).toBeCloseTo(10, 9);
+ });
+
+ it('restores the exact total area when removing a visual split line', () => {
+ const state: any = {
+ selectedIdx: 0,
+ integrations: [{
+ stack: [{ xL: 0, xU: 10, area: 300, absoluteArea: 60 }],
+ refArea: 300,
+ refFactor: 1,
+ shift: 0,
+ edited: false,
+ }],
+ };
+
+ const split = integrationReducer(state, {
+ type: INTEGRATION.ADD_VISUAL_SPLIT,
+ payload: {
+ curveIdx: 0, target: { xL: 0, xU: 10 }, splitX: 4, data,
+ },
+ });
+ expect(split.integrations[0].stack).toHaveLength(2);
+
+ const merged = integrationReducer(split, {
+ type: INTEGRATION.RM_VISUAL_SPLIT,
+ payload: { curveIdx: 0, splitX: 4, data },
+ });
+
+ expect(merged.integrations[0].stack).toHaveLength(1);
+ expect(merged.integrations[0].stack[0].area).toBeCloseTo(300, 9);
+ expect(merged.integrations[0].stack[0].absoluteArea).toBeCloseTo(60, 9);
+ });
+
+ it('allows visually splitting again after the only split line has been removed', () => {
+ const state: any = {
+ selectedIdx: 0,
+ integrations: [{
+ stack: [
+ { xL: 0, xU: 4, area: 4, absoluteArea: 0, visualSplitGroupId: 'g1' },
+ { xL: 4, xU: 10, area: 6, absoluteArea: 0, visualSplitGroupId: 'g1' },
+ ],
+ refArea: 10,
+ refFactor: 1,
+ shift: 0,
+ edited: false,
+ }],
+ };
+
+ const merged = integrationReducer(state, {
+ type: INTEGRATION.RM_VISUAL_SPLIT,
+ payload: { curveIdx: 0, splitX: 4, data },
+ });
+ expect(merged.integrations[0].stack).toHaveLength(1);
+ expect(merged.integrations[0].stack[0].visualSplitGroupId).toBeUndefined();
+
+ const reSplit = integrationReducer(merged, {
+ type: INTEGRATION.ADD_VISUAL_SPLIT,
+ payload: {
+ curveIdx: 0,
+ target: { xL: 0, xU: 10 },
+ splitX: 6,
+ data,
+ },
+ });
+
+ expect(reSplit.integrations[0].stack).toHaveLength(2);
+ expect(reSplit.integrations[0].stack[0]).toMatchObject({ xL: 0, xU: 6 });
+ expect(reSplit.integrations[0].stack[1]).toMatchObject({ xL: 6, xU: 10 });
+ const newGroupId = reSplit.integrations[0].stack[0].visualSplitGroupId;
+ expect(typeof newGroupId).toBe('string');
+ expect(reSplit.integrations[0].stack[1].visualSplitGroupId).toBe(newGroupId);
+ });
+
+ it('removes a visual split line by merging the two adjacent grouped items', () => {
+ const state: any = {
+ selectedIdx: 0,
+ integrations: [{
+ stack: [
+ { xL: 0, xU: 4, area: 4, absoluteArea: 0, visualSplitGroupId: 'g1' },
+ { xL: 4, xU: 6, area: 2, absoluteArea: 0, visualSplitGroupId: 'g1' },
+ { xL: 6, xU: 10, area: 4, absoluteArea: 0, visualSplitGroupId: 'g1' },
+ ],
+ refArea: 10,
+ refFactor: 1,
+ shift: 0,
+ edited: false,
+ }],
+ };
+
+ const newState = integrationReducer(state, {
+ type: INTEGRATION.RM_VISUAL_SPLIT,
+ payload: { curveIdx: 0, splitX: 4, data },
+ });
+
+ expect(newState.integrations[0].stack).toHaveLength(2);
+ expect(newState.integrations[0].stack[0]).toMatchObject({ xL: 0, xU: 6, visualSplitGroupId: 'g1' });
+ expect(newState.integrations[0].stack[1]).toMatchObject({ xL: 6, xU: 10, visualSplitGroupId: 'g1' });
+ });
+
+ it('strips the orphan groupId when one child of a visual split group is removed', () => {
+ const state: any = {
+ selectedIdx: 0,
+ integrations: [{
+ stack: [
+ { xL: 0, xU: 4, area: 4, absoluteArea: 0, visualSplitGroupId: 'g1' },
+ { xL: 4, xU: 10, area: 6, absoluteArea: 0, visualSplitGroupId: 'g1' },
+ ],
+ refArea: 10,
+ refFactor: 1,
+ shift: 0,
+ edited: false,
+ }],
+ };
+
+ const afterRemove = integrationReducer(state, {
+ type: INTEGRATION.RM_ONE,
+ payload: { curveIdx: 0, dataToRemove: { xL: 0, xU: 4 } },
+ });
+
+ expect(afterRemove.integrations[0].stack).toHaveLength(1);
+ expect(afterRemove.integrations[0].stack[0]).toMatchObject({ xL: 4, xU: 10 });
+ expect(afterRemove.integrations[0].stack[0].visualSplitGroupId).toBeUndefined();
+
+ const reSplit = integrationReducer(afterRemove, {
+ type: INTEGRATION.ADD_VISUAL_SPLIT,
+ payload: {
+ curveIdx: 0,
+ target: { xL: 4, xU: 10 },
+ splitX: 6,
+ data,
+ },
+ });
+ expect(reSplit.integrations[0].stack).toHaveLength(2);
+ const reSplitGroupId = reSplit.integrations[0].stack[0].visualSplitGroupId;
+ expect(typeof reSplitGroupId).toBe('string');
+ expect(reSplit.integrations[0].stack[1].visualSplitGroupId).toBe(reSplitGroupId);
+ });
+
+ it('extracts the outer part of a left visual split child and keeps the inner part in the group', () => {
+ const state: any = {
+ selectedIdx: 0,
+ integrations: [{
+ stack: [
+ { xL: 0, xU: 4, area: 4, absoluteArea: 40, visualSplitGroupId: 'g1' },
+ { xL: 4, xU: 10, area: 6, absoluteArea: 60, visualSplitGroupId: 'g1' },
+ ],
+ refArea: 10,
+ refFactor: 1,
+ shift: 0,
+ edited: false,
+ }],
+ };
+
+ const afterSplit = integrationReducer(state, {
+ type: INTEGRATION.SPLIT,
+ payload: {
+ curveIdx: 0,
+ target: { xL: 0, xU: 4 },
+ splitX: 2,
+ data,
+ },
+ });
+
+ expect(afterSplit.integrations[0].stack).toHaveLength(3);
+ const [extracted, kept, sibling] = afterSplit.integrations[0].stack;
+
+ expect(extracted).toMatchObject({ xL: 0, xU: 2 });
+ expect(extracted.visualSplitGroupId).toBeUndefined();
+
+ expect(kept).toMatchObject({ xL: 2, xU: 4, visualSplitGroupId: 'g1' });
+ expect(sibling).toMatchObject({ xL: 4, xU: 10, visualSplitGroupId: 'g1' });
+
+ expect(extracted.area + kept.area).toBeCloseTo(4);
+ expect(extracted.absoluteArea + kept.absoluteArea).toBeCloseTo(40);
+ });
+
+ it('extracts the outer part of a right visual split child and keeps the inner part in the group', () => {
+ const state: any = {
+ selectedIdx: 0,
+ integrations: [{
+ stack: [
+ { xL: 0, xU: 4, area: 4, absoluteArea: 40, visualSplitGroupId: 'g1' },
+ { xL: 4, xU: 10, area: 6, absoluteArea: 60, visualSplitGroupId: 'g1' },
+ ],
+ refArea: 10,
+ refFactor: 1,
+ shift: 0,
+ edited: false,
+ }],
+ };
+
+ const afterSplit = integrationReducer(state, {
+ type: INTEGRATION.SPLIT,
+ payload: {
+ curveIdx: 0,
+ target: { xL: 4, xU: 10 },
+ splitX: 8,
+ data,
+ },
+ });
+
+ expect(afterSplit.integrations[0].stack).toHaveLength(3);
+ const [sibling, kept, extracted] = afterSplit.integrations[0].stack;
+
+ expect(sibling).toMatchObject({ xL: 0, xU: 4, visualSplitGroupId: 'g1' });
+ expect(kept).toMatchObject({ xL: 4, xU: 8, visualSplitGroupId: 'g1' });
+ expect(extracted).toMatchObject({ xL: 8, xU: 10 });
+ expect(extracted.visualSplitGroupId).toBeUndefined();
+
+ expect(kept.area + extracted.area).toBeCloseTo(6);
+ expect(kept.absoluteArea + extracted.absoluteArea).toBeCloseTo(60);
+ });
+
+ it('keeps both halves in the group when regular-splitting a middle child', () => {
+ const state: any = {
+ selectedIdx: 0,
+ integrations: [{
+ stack: [
+ { xL: 0, xU: 2, area: 2, absoluteArea: 20, visualSplitGroupId: 'g1' },
+ { xL: 2, xU: 8, area: 6, absoluteArea: 60, visualSplitGroupId: 'g1' },
+ { xL: 8, xU: 10, area: 2, absoluteArea: 20, visualSplitGroupId: 'g1' },
+ ],
+ refArea: 10,
+ refFactor: 1,
+ shift: 0,
+ edited: false,
+ }],
+ };
+
+ const afterSplit = integrationReducer(state, {
+ type: INTEGRATION.SPLIT,
+ payload: {
+ curveIdx: 0,
+ target: { xL: 2, xU: 8 },
+ splitX: 5,
+ data,
+ },
+ });
+
+ expect(afterSplit.integrations[0].stack).toHaveLength(4);
+ expect(afterSplit.integrations[0].stack.every((it: any) => it.visualSplitGroupId === 'g1')).toBe(true);
+ });
+
+ it('drops the groupId when removing the last visual split line of a group', () => {
+ const state: any = {
+ selectedIdx: 0,
+ integrations: [{
+ stack: [
+ { xL: 0, xU: 4, area: 4, absoluteArea: 0, visualSplitGroupId: 'g1' },
+ { xL: 4, xU: 10, area: 6, absoluteArea: 0, visualSplitGroupId: 'g1' },
+ ],
+ refArea: 10,
+ refFactor: 1,
+ shift: 0,
+ edited: false,
+ }],
+ };
+
+ const newState = integrationReducer(state, {
+ type: INTEGRATION.RM_VISUAL_SPLIT,
+ payload: { curveIdx: 0, splitX: 4, data },
+ });
+
+ expect(newState.integrations[0].stack).toHaveLength(1);
+ expect(newState.integrations[0].stack[0]).toMatchObject({ xL: 0, xU: 10 });
+ expect(newState.integrations[0].stack[0].visualSplitGroupId).toBeUndefined();
+ });
+
+ it('undoes adding a visual split line in one step', () => {
+ const state: any = {
+ selectedIdx: 0,
+ integrations: [{
+ stack: [{ xL: 0, xU: 10, area: 10, absoluteArea: 0 }],
+ refArea: 10,
+ refFactor: 1,
+ shift: 0,
+ edited: false,
+ }],
+ };
+ const splitPresent = integrationReducer(state, {
+ type: INTEGRATION.ADD_VISUAL_SPLIT,
+ payload: {
+ curveIdx: 0,
+ target: { xL: 0, xU: 10 },
+ splitX: 4,
+ data,
+ },
+ });
+ const splitState: any = newHistory([state], splitPresent, []);
+ const undoneState = undoableIntegrationReducer(splitState, ActionCreators.undo());
+
+ expect(splitState.present.integrations[0].stack).toHaveLength(2);
+ expect(undoneState.present.integrations[0].stack).toEqual(state.integrations[0].stack);
+ });
+
+ it('undoes extracting a child from a visual split group in one step', () => {
+ const state: any = {
+ selectedIdx: 0,
+ integrations: [{
+ stack: [
+ { xL: 0, xU: 4, area: 4, absoluteArea: 40, visualSplitGroupId: 'g1' },
+ { xL: 4, xU: 10, area: 6, absoluteArea: 60, visualSplitGroupId: 'g1' },
+ ],
+ refArea: 10,
+ refFactor: 1,
+ shift: 0,
+ edited: false,
+ }],
+ };
+ const splitPresent = integrationReducer(state, {
+ type: INTEGRATION.SPLIT,
+ payload: {
+ curveIdx: 0,
+ target: { xL: 0, xU: 4 },
+ splitX: 2,
+ data,
+ },
+ });
+ const splitState: any = newHistory([state], splitPresent, []);
+ const undoneState = undoableIntegrationReducer(splitState, ActionCreators.undo());
+
+ expect(splitState.present.integrations[0].stack).toHaveLength(3);
+ expect(splitState.present.integrations[0].stack[0].visualSplitGroupId).toBeUndefined();
+ expect(splitState.present.integrations[0].stack[1].visualSplitGroupId).toBe('g1');
+ expect(splitState.present.integrations[0].stack[2].visualSplitGroupId).toBe('g1');
+
+ expect(undoneState.present.integrations[0].stack).toEqual(state.integrations[0].stack);
+ expect(undoneState.present.integrations[0].stack[0].visualSplitGroupId).toBe('g1');
+ expect(undoneState.present.integrations[0].stack[1].visualSplitGroupId).toBe('g1');
+
+ const redoneState = undoableIntegrationReducer(undoneState, ActionCreators.redo());
+ expect(redoneState.present.integrations[0].stack).toEqual(splitPresent.integrations[0].stack);
+ });
+
+ it('undoes removing a visual split line in one step', () => {
+ const state: any = {
+ selectedIdx: 0,
+ integrations: [{
+ stack: [
+ { xL: 0, xU: 4, area: 4, absoluteArea: 0, visualSplitGroupId: 'g1' },
+ { xL: 4, xU: 10, area: 6, absoluteArea: 0, visualSplitGroupId: 'g1' },
+ ],
+ refArea: 10,
+ refFactor: 1,
+ shift: 0,
+ edited: false,
+ }],
+ };
+ const removedPresent = integrationReducer(state, {
+ type: INTEGRATION.RM_VISUAL_SPLIT,
+ payload: { curveIdx: 0, splitX: 4, data },
+ });
+ const removedState: any = newHistory([state], removedPresent, []);
+ const undoneState = undoableIntegrationReducer(removedState, ActionCreators.undo());
+
+ expect(removedState.present.integrations[0].stack).toHaveLength(1);
+ expect(undoneState.present.integrations[0].stack).toEqual(state.integrations[0].stack);
+ });
+
+ it('preserves visualSplitGroupId metadata when restoring integrations via RESET_ALL_RDC', () => {
+ const initial: any = {
+ selectedIdx: 0,
+ integrations: [{
+ stack: [],
+ refArea: 1,
+ refFactor: 1,
+ shift: 0,
+ edited: false,
+ }],
+ };
+ const restored = integrationReducer(initial, {
+ type: INTEGRATION.RESET_ALL_RDC,
+ payload: {
+ selectedIdx: 0,
+ integrations: [
+ {
+ stack: [
+ { xL: 0, xU: 3, area: 3, absoluteArea: 1, visualSplitGroupId: 'g1' },
+ { xL: 3, xU: 10, area: 7, absoluteArea: 4, visualSplitGroupId: 'g1' },
+ ],
+ refArea: 10,
+ refFactor: 1,
+ shift: 0,
+ edited: false,
+ },
+ ],
+ },
+ });
+
+ expect(restored.integrations[0].stack[0]).toMatchObject({
+ xL: 0, xU: 3, visualSplitGroupId: 'g1',
+ });
+ expect(restored.integrations[0].stack[1]).toMatchObject({
+ xL: 3, xU: 10, visualSplitGroupId: 'g1',
+ });
+ });
+
+ it('preserves visualSplitGroupId across multi-curve integrations via RESET_ALL_RDC', () => {
+ const initial: any = {
+ selectedIdx: 0,
+ integrations: [
+ { stack: [], refArea: 1, refFactor: 1, shift: 0, edited: false },
+ { stack: [], refArea: 1, refFactor: 1, shift: 0, edited: false },
+ ],
+ };
+ const restored = integrationReducer(initial, {
+ type: INTEGRATION.RESET_ALL_RDC,
+ payload: {
+ selectedIdx: 1,
+ integrations: [
+ {
+ stack: [{ xL: 0, xU: 4, area: 4, absoluteArea: 2 }],
+ refArea: 4,
+ refFactor: 1,
+ shift: 0,
+ edited: false,
+ },
+ {
+ stack: [
+ { xL: 5, xU: 7, area: 2, absoluteArea: 1, visualSplitGroupId: 'g2' },
+ { xL: 7, xU: 9, area: 2, absoluteArea: 1, visualSplitGroupId: 'g2' },
+ ],
+ refArea: 4,
+ refFactor: 1,
+ shift: 0,
+ edited: false,
+ },
+ ],
+ },
+ });
+
+ expect(restored.integrations[0].stack[0].visualSplitGroupId).toBeUndefined();
+ expect(restored.integrations[1].stack[0].visualSplitGroupId).toBe('g2');
+ expect(restored.integrations[1].stack[1].visualSplitGroupId).toBe('g2');
+ });
+
+ it('rejects visual split lines too close to an integration edge', () => {
+ const state: any = {
+ selectedIdx: 0,
+ integrations: [{
+ stack: [{ xL: 0, xU: 10, area: 10, absoluteArea: 0 }],
+ refArea: 10,
+ refFactor: 1,
+ shift: 0,
+ edited: false,
+ }],
+ };
+
+ const newState = integrationReducer(state, {
+ type: INTEGRATION.ADD_VISUAL_SPLIT,
+ payload: {
+ curveIdx: 0,
+ target: { xL: 0, xU: 10 },
+ splitX: 0,
+ data,
+ },
+ });
+
+ expect(newState).toBe(state);
+ });
+});
diff --git a/src/actions/integration.js b/src/actions/integration.js
index b594b852..0d25e9e8 100644
--- a/src/actions/integration.js
+++ b/src/actions/integration.js
@@ -21,8 +21,32 @@ const clearIntegrationAll = (payload) => (
}
);
+const splitIntegration = (payload) => (
+ {
+ type: INTEGRATION.SPLIT,
+ payload,
+ }
+);
+
+const addVisualSplitLine = (payload) => (
+ {
+ type: INTEGRATION.ADD_VISUAL_SPLIT,
+ payload,
+ }
+);
+
+const removeVisualSplitLine = (payload) => (
+ {
+ type: INTEGRATION.RM_VISUAL_SPLIT,
+ payload,
+ }
+);
+
export {
+ addVisualSplitLine,
sweepIntegration,
setIntegrationFkr,
clearIntegrationAll,
+ removeVisualSplitLine,
+ splitIntegration,
}; // eslint-disable-line
diff --git a/src/actions/ui.js b/src/actions/ui.js
index 46424f92..4e9a8c51 100644
--- a/src/actions/ui.js
+++ b/src/actions/ui.js
@@ -1,19 +1,38 @@
import { UI } from '../constants/action_type';
+import { LIST_UI_SWEEP_TYPE } from '../constants/list_ui';
+import { confirmCancelPendingIntegration } from '../helpers/integration_draft.js'; // eslint-disable-line import/extensions
-const setUiViewerType = (payload) => (
- {
+const keepIntegrationMode = (jcampIdx = 0) => ({
+ type: UI.SWEEP.SET_TYPE,
+ payload: LIST_UI_SWEEP_TYPE.INTEGRATION_ADD,
+ jcampIdx,
+});
+
+const setUiViewerType = (payload) => {
+ if (!confirmCancelPendingIntegration()) {
+ return keepIntegrationMode();
+ }
+
+ return {
type: UI.VIEWER.SET_TYPE,
payload,
+ };
+};
+
+const setUiSweepType = (payload, jcampIdx = 0) => {
+ if (
+ payload !== LIST_UI_SWEEP_TYPE.INTEGRATION_ADD
+ && !confirmCancelPendingIntegration()
+ ) {
+ return keepIntegrationMode(jcampIdx);
}
-);
-const setUiSweepType = (payload, jcampIdx = 0) => (
- {
+ return {
type: UI.SWEEP.SET_TYPE,
payload,
jcampIdx,
- }
-);
+ };
+};
const selectUiSweep = (payload) => (
{
diff --git a/src/components/cmd_bar/04_integration.js b/src/components/cmd_bar/04_integration.js
index 77356585..c3388c29 100644
--- a/src/components/cmd_bar/04_integration.js
+++ b/src/components/cmd_bar/04_integration.js
@@ -12,7 +12,7 @@ import Tooltip from '@mui/material/Tooltip';
import TextField from '@mui/material/TextField';
import Icon from '@mdi/react';
-import { mdiReflectVertical, mdiMathIntegral } from '@mdi/js';
+import { mdiClose, mdiReflectVertical, mdiMathIntegral } from '@mdi/js';
import {
clearIntegrationAll, setIntegrationFkr,
@@ -21,6 +21,7 @@ import { setUiSweepType } from '../../actions/ui';
import {
LIST_UI_SWEEP_TYPE,
} from '../../constants/list_ui';
+import { clearPendingIntegrationDraft } from '../../helpers/integration_draft.js'; // eslint-disable-line import/extensions
import Cfg from '../../helpers/cfg';
import TriBtn from './tri_btn';
import { MuButton, commonStyle, focusStyle } from './common';
@@ -34,6 +35,13 @@ const styles = () => (
},
txtIcon: {
},
+ cancelBtn: {
+ borderColor: '#d32f2f',
+ color: '#d32f2f',
+ '&:hover': {
+ backgroundColor: '#ffebee',
+ },
+ },
},
commonStyle,
)
@@ -92,13 +100,36 @@ const iconColor = (criteria) => (criteria ? '#fff' : '#000');
const Integration = ({
classes, ignoreRef,
isDisableSt, isFocusAddIntgSt, isFocusRmIntgSt, isFocusSetRefSt,
+ isFocusSplitIntgSt, isFocusVisualSplitIntgSt,
setUiSweepTypeAct, setIntegrationFkrAct, clearIntegrationAllAct,
curveSt, integrationSt,
}) => {
- const onSweepIntegtAdd = () => setUiSweepTypeAct(LIST_UI_SWEEP_TYPE.INTEGRATION_ADD);
+ const { curveIdx } = curveSt;
+ const onCancelTool = () => setUiSweepTypeAct(LIST_UI_SWEEP_TYPE.ZOOMIN, curveIdx);
+ const onSweepIntegtAdd = () => {
+ if (isFocusAddIntgSt) {
+ clearPendingIntegrationDraft();
+ onCancelTool();
+ return;
+ }
+ setUiSweepTypeAct(LIST_UI_SWEEP_TYPE.INTEGRATION_ADD, curveIdx);
+ };
const onSweepIntegtRm = () => setUiSweepTypeAct(LIST_UI_SWEEP_TYPE.INTEGRATION_RM);
const onSweepIntegtSR = () => setUiSweepTypeAct(LIST_UI_SWEEP_TYPE.INTEGRATION_SET_REF);
- const { curveIdx } = curveSt;
+ const onSweepIntegtSplit = () => {
+ if (isFocusSplitIntgSt) {
+ onCancelTool();
+ return;
+ }
+ setUiSweepTypeAct(LIST_UI_SWEEP_TYPE.INTEGRATION_SPLIT, curveIdx);
+ };
+ const onSweepIntegtVisualSplit = () => {
+ if (isFocusVisualSplitIntgSt) {
+ onCancelTool();
+ return;
+ }
+ setUiSweepTypeAct(LIST_UI_SWEEP_TYPE.INTEGRATION_VISUAL_SPLIT, curveIdx);
+ };
const onClearAll = () => clearIntegrationAllAct({ curveIdx });
return (
@@ -108,7 +139,7 @@ const Integration = ({
- +
+ {
+ isFocusAddIntgSt
+ ? null
+ : +
+ }
@@ -147,24 +182,82 @@ const Integration = ({
- Set Integration Reference}>
+ {
+ ignoreRef
+ ? null
+ : (
+ Set Integration Reference}>
+
+
+
+
+
+
+ )
+ }
+ Split Integration}>
+
+
+
+ {
+ isFocusSplitIntgSt
+ ? null
+ : /
+ }
+
+
+
+ Visual Split Integration}>
+ {
+ isFocusVisualSplitIntgSt
+ ? null
+ : |
+ }
@@ -197,6 +290,8 @@ const mapStateToProps = (state, props) => ( // eslint-disable-line
isFocusAddIntgSt: state.ui.sweepType === LIST_UI_SWEEP_TYPE.INTEGRATION_ADD,
isFocusRmIntgSt: state.ui.sweepType === LIST_UI_SWEEP_TYPE.INTEGRATION_RM,
isFocusSetRefSt: state.ui.sweepType === LIST_UI_SWEEP_TYPE.INTEGRATION_SET_REF,
+ isFocusSplitIntgSt: state.ui.sweepType === LIST_UI_SWEEP_TYPE.INTEGRATION_SPLIT,
+ isFocusVisualSplitIntgSt: state.ui.sweepType === LIST_UI_SWEEP_TYPE.INTEGRATION_VISUAL_SPLIT,
ignoreRef: Format.isHplcUvVisLayout(state.layout),
curveSt: state.curve,
integrationSt: state.integration.present,
@@ -217,6 +312,8 @@ Integration.propTypes = {
isFocusAddIntgSt: PropTypes.bool.isRequired,
isFocusRmIntgSt: PropTypes.bool.isRequired,
isFocusSetRefSt: PropTypes.bool.isRequired,
+ isFocusSplitIntgSt: PropTypes.bool.isRequired,
+ isFocusVisualSplitIntgSt: PropTypes.bool.isRequired,
ignoreRef: PropTypes.bool.isRequired,
setUiSweepTypeAct: PropTypes.func.isRequired,
setIntegrationFkrAct: PropTypes.func.isRequired,
diff --git a/src/components/d3_line/index.js b/src/components/d3_line/index.js
index d42c2796..ebe1a4c7 100644
--- a/src/components/d3_line/index.js
+++ b/src/components/d3_line/index.js
@@ -10,6 +10,9 @@ import {
} from '../../helpers/chem';
import { resetAll } from '../../actions/manager';
import { selectUiSweep, scrollUiWheel, clickUiTarget } from '../../actions/ui';
+import {
+ addVisualSplitLine, removeVisualSplitLine, splitIntegration,
+} from '../../actions/integration';
import LineFocus from './line_focus';
import {
drawMain, drawLabel, drawDisplay, drawDestroy,
@@ -24,23 +27,35 @@ class ViewerLine extends React.Component {
constructor(props) {
super(props);
- const { clickUiTargetAct, selectUiSweepAct, scrollUiWheelAct } = props;
+ const {
+ clickUiTargetAct, selectUiSweepAct, scrollUiWheelAct, splitIntegrationAct,
+ addVisualSplitLineAct, removeVisualSplitLineAct,
+ } = props;
this.rootKlass = '.d3Line';
this.focus = new LineFocus({
- W, H, clickUiTargetAct, selectUiSweepAct, scrollUiWheelAct,
+ W,
+ H,
+ clickUiTargetAct,
+ selectUiSweepAct,
+ scrollUiWheelAct,
+ splitIntegrationAct,
+ addVisualSplitLineAct,
+ removeVisualSplitLineAct,
});
this.normChange = this.normChange.bind(this);
+ this.syncFocusActions = this.syncFocusActions.bind(this);
}
componentDidMount() {
const {
seed, peak, cLabel, xLabel, yLabel, feature, freq, comparisons,
tTrEndPts, tSfPeaks, editPeakSt, layoutSt, integationSt, mtplySt,
- sweepExtentSt, isUiAddIntgSt, isUiNoBrushSt,
+ sweepExtentSt, isUiAddIntgSt, isUiSplitIntgSt, isUiVisualSplitIntgSt, isUiNoBrushSt,
isHidden, wavelength, axesUnitsSt,
resetAllAct,
} = this.props;
+ this.syncFocusActions();
drawDestroy(this.rootKlass);
resetAllAct(feature);
@@ -71,6 +86,8 @@ class ViewerLine extends React.Component {
mtplySt,
sweepExtentSt,
isUiAddIntgSt,
+ isUiSplitIntgSt,
+ isUiVisualSplitIntgSt,
isUiNoBrushSt,
wavelength,
});
@@ -82,9 +99,10 @@ class ViewerLine extends React.Component {
const {
seed, peak, cLabel, xLabel, yLabel, freq, comparisons,
tTrEndPts, tSfPeaks, editPeakSt, layoutSt, integationSt, mtplySt,
- sweepExtentSt, isUiAddIntgSt, isUiNoBrushSt,
+ sweepExtentSt, isUiAddIntgSt, isUiSplitIntgSt, isUiVisualSplitIntgSt, isUiNoBrushSt,
isHidden, wavelength, axesUnitsSt,
} = this.props;
+ this.syncFocusActions();
this.normChange(prevProps);
let xxLabel = xLabel;
@@ -113,6 +131,8 @@ class ViewerLine extends React.Component {
mtplySt,
sweepExtentSt,
isUiAddIntgSt,
+ isUiSplitIntgSt,
+ isUiVisualSplitIntgSt,
isUiNoBrushSt,
wavelength,
});
@@ -124,6 +144,22 @@ class ViewerLine extends React.Component {
drawDestroy(this.rootKlass);
}
+ syncFocusActions() {
+ if (!this.focus) return;
+ const {
+ clickUiTargetAct, selectUiSweepAct, scrollUiWheelAct,
+ splitIntegrationAct, addVisualSplitLineAct, removeVisualSplitLineAct,
+ } = this.props;
+ Object.assign(this.focus, {
+ clickUiTargetAct,
+ selectUiSweepAct,
+ scrollUiWheelAct,
+ splitIntegrationAct,
+ addVisualSplitLineAct,
+ removeVisualSplitLineAct,
+ });
+ }
+
normChange(prevProps) {
const { feature, resetAllAct } = this.props;
const oldFeature = prevProps.feature;
@@ -153,6 +189,8 @@ const mapStateToProps = (state, props) => (
mtplySt: state.multiplicity.present,
sweepExtentSt: state.ui.sweepExtent,
isUiAddIntgSt: state.ui.sweepType === LIST_UI_SWEEP_TYPE.INTEGRATION_ADD,
+ isUiSplitIntgSt: state.ui.sweepType === LIST_UI_SWEEP_TYPE.INTEGRATION_SPLIT,
+ isUiVisualSplitIntgSt: state.ui.sweepType === LIST_UI_SWEEP_TYPE.INTEGRATION_VISUAL_SPLIT,
isUiNoBrushSt: LIST_NON_BRUSH_TYPES.indexOf(state.ui.sweepType) < 0,
wavelength: state.wavelength,
axesUnitsSt: state.axesUnits,
@@ -165,6 +203,9 @@ const mapDispatchToProps = (dispatch) => (
clickUiTargetAct: clickUiTarget,
selectUiSweepAct: selectUiSweep,
scrollUiWheelAct: scrollUiWheel,
+ splitIntegrationAct: splitIntegration,
+ addVisualSplitLineAct: addVisualSplitLine,
+ removeVisualSplitLineAct: removeVisualSplitLine,
addNewCylicVoltaPairPeakAct: addNewCylicVoltaPairPeak,
addCylicVoltaMaxPeakAct: addCylicVoltaMaxPeak,
addCylicVoltaMinPeakAct: addCylicVoltaMinPeak,
@@ -191,11 +232,16 @@ ViewerLine.propTypes = {
mtplySt: PropTypes.object.isRequired,
sweepExtentSt: PropTypes.object.isRequired,
isUiAddIntgSt: PropTypes.bool.isRequired,
+ isUiSplitIntgSt: PropTypes.bool.isRequired,
+ isUiVisualSplitIntgSt: PropTypes.bool.isRequired,
isUiNoBrushSt: PropTypes.bool.isRequired,
resetAllAct: PropTypes.func.isRequired,
clickUiTargetAct: PropTypes.func.isRequired,
selectUiSweepAct: PropTypes.func.isRequired,
scrollUiWheelAct: PropTypes.func.isRequired,
+ splitIntegrationAct: PropTypes.func.isRequired,
+ addVisualSplitLineAct: PropTypes.func.isRequired,
+ removeVisualSplitLineAct: PropTypes.func.isRequired,
isHidden: PropTypes.bool.isRequired,
wavelength: PropTypes.object.isRequired,
axesUnitsSt: PropTypes.object.isRequired,
diff --git a/src/components/d3_line/line_focus.js b/src/components/d3_line/line_focus.js
index b308e9d3..ca37975b 100644
--- a/src/components/d3_line/line_focus.js
+++ b/src/components/d3_line/line_focus.js
@@ -8,14 +8,24 @@ import {
} from '../../helpers/mount';
import MountBrush from '../../helpers/brush';
import { TfRescale, MountCompass } from '../../helpers/compass';
+import {
+ clearIntegrationSplitPreview,
+ drawIntegrationSplitPreview,
+ drawIntegrationVisualSplitLines,
+ getSplitXFromEvent,
+ getVisualSplitLineAtX,
+ isAlreadyVisuallySplit,
+ isMergedVisualSplitGroup,
+} from '../../helpers/integration_split';
import { PksEdit } from '../../helpers/converter';
import { itgIdTag, mpyIdTag } from '../../helpers/focus';
-import { calcArea } from '../../helpers/integration';
+import {
+ calcArea, getIntegrationPoints, getLinearBaseline, getVisualSplitGroups,
+} from '../../helpers/integration';
import { calcMpyCenter } from '../../helpers/multiplicity_calc';
import Format from '../../helpers/format';
import Cfg from '../../helpers/cfg';
import { LIST_LAYOUT } from '../../constants/list_layout';
-import { calcSlope } from '../../helpers/calc';
const d3 = require('d3');
@@ -23,6 +33,7 @@ class LineFocus {
constructor(props) {
const {
W, H, clickUiTargetAct, selectUiSweepAct, scrollUiWheelAct,
+ splitIntegrationAct, addVisualSplitLineAct, removeVisualSplitLineAct,
} = props;
this.jcampIdx = 0;
@@ -38,6 +49,9 @@ class LineFocus {
this.clickUiTargetAct = clickUiTargetAct;
this.selectUiSweepAct = selectUiSweepAct;
this.scrollUiWheelAct = scrollUiWheelAct;
+ this.splitIntegrationAct = splitIntegrationAct;
+ this.addVisualSplitLineAct = addVisualSplitLineAct;
+ this.removeVisualSplitLineAct = removeVisualSplitLineAct;
this.brush = d3.brush();
this.brushX = d3.brushX();
@@ -63,6 +77,11 @@ class LineFocus {
this.shouldUpdate = {};
this.freq = false;
this.layout = LIST_LAYOUT.H1;
+ this.isUiAddIntgSt = false;
+ this.isUiSplitIntgSt = false;
+ this.isUiVisualSplitIntgSt = false;
+ this.integrationSplitTargets = null;
+ this.firstIntegrationPoint = null;
this.getShouldUpdate = this.getShouldUpdate.bind(this);
this.resetShouldUpdate = this.resetShouldUpdate.bind(this);
@@ -81,6 +100,11 @@ class LineFocus {
this.drawMtply = this.drawMtply.bind(this);
this.drawComparisons = this.drawComparisons.bind(this);
this.onClickTarget = this.onClickTarget.bind(this);
+ this.onClickIntegrationTarget = this.onClickIntegrationTarget.bind(this);
+ this.onClickVisualSplitLine = this.onClickVisualSplitLine.bind(this);
+ this.onIntegrationMouseMove = this.onIntegrationMouseMove.bind(this);
+ this.clearSplitPreview = this.clearSplitPreview.bind(this);
+ this.drawVisualSplitLines = this.drawVisualSplitLines.bind(this);
this.mergedPeaks = this.mergedPeaks.bind(this);
this.isFirefox = typeof InstallTrigger !== 'undefined';
@@ -233,40 +257,119 @@ class LineFocus {
this.clickUiTargetAct(data, onPeak);
}
+ clearSplitPreview() {
+ clearIntegrationSplitPreview(this);
+ }
+
+ onIntegrationMouseMove(event, data, shift, ignoreRef) {
+ if (!this.isUiSplitIntgSt && !this.isUiVisualSplitIntgSt) return;
+ if (this.isUiVisualSplitIntgSt && isAlreadyVisuallySplit(data)) {
+ this.clearSplitPreview();
+ return;
+ }
+ if (this.isUiSplitIntgSt && isMergedVisualSplitGroup(data)) {
+ this.clearSplitPreview();
+ return;
+ }
+ const splitX = getSplitXFromEvent(event, this);
+ drawIntegrationSplitPreview(this, data, splitX, shift, ignoreRef);
+ }
+
+ onClickIntegrationTarget(event, data) {
+ if (!this.isUiSplitIntgSt && !this.isUiVisualSplitIntgSt) {
+ this.onClickTarget(event, data);
+ return;
+ }
+
+ event.stopPropagation();
+ event.preventDefault();
+ const splitX = getSplitXFromEvent(event, this);
+ this.clearSplitPreview();
+ if (this.isUiVisualSplitIntgSt) {
+ const { stack = [], shift = 0 } = this.integrationSplitTargets || {};
+ const existingSplitX = getVisualSplitLineAtX(this, stack, splitX, shift);
+ if (Number.isFinite(existingSplitX)) {
+ if (typeof this.removeVisualSplitLineAct !== 'function') return;
+ this.removeVisualSplitLineAct({
+ curveIdx: this.jcampIdx,
+ splitX: existingSplitX,
+ data: this.data,
+ });
+ return;
+ }
+ if (isAlreadyVisuallySplit(data)) return;
+ if (typeof this.addVisualSplitLineAct !== 'function') return;
+ this.addVisualSplitLineAct({
+ curveIdx: this.jcampIdx,
+ target: data,
+ splitX,
+ data: this.data,
+ });
+ return;
+ }
+
+ if (isMergedVisualSplitGroup(data)) return;
+ this.splitIntegrationAct({
+ curveIdx: this.jcampIdx,
+ target: data,
+ splitX,
+ data: this.data,
+ });
+ }
+
+ onClickVisualSplitLine(event, splitX) {
+ event.stopPropagation();
+ event.preventDefault();
+ this.clearSplitPreview();
+ if (typeof this.removeVisualSplitLineAct !== 'function') return;
+ this.removeVisualSplitLineAct({
+ curveIdx: this.jcampIdx,
+ splitX,
+ data: this.data,
+ });
+ }
+
+ drawVisualSplitLines(stack, shift, ignoreRef) {
+ drawIntegrationVisualSplitLines(
+ this,
+ stack,
+ shift,
+ ignoreRef,
+ this.isUiVisualSplitIntgSt,
+ this.onClickVisualSplitLine,
+ );
+ }
+
mergedPeaks(editPeakSt) {
if (!editPeakSt) return this.dataPks;
this.dataPks = PksEdit(this.dataPks, editPeakSt);
return this.dataPks;
}
- drawAUC(stack) {
+ drawAUC(stack, shift = 0) {
const { xt, yt } = TfRescale(this);
- const auc = this.tags.aucPath.selectAll('path').data(stack);
+ const groups = getVisualSplitGroups(stack).map((group) => ({
+ xL: group.xL,
+ xU: group.xU,
+ isMerged: group.isMerged,
+ groupId: group.groupId,
+ target: group.items[0],
+ }));
+ const auc = this.tags.aucPath.selectAll('path').data(groups);
auc.exit()
.attr('class', 'exit')
.remove();
const integCurve = (border) => {
const { xL, xU } = border;
- const ps = this.data.filter((d) => d.x > xL && d.x < xU);
+ const ps = getIntegrationPoints(xL - shift, xU - shift, this.data);
if (!ps[0]) return null;
- const point1 = ps[0];
- const point2 = ps[ps.length - 1];
- const slope = calcSlope(point1.x, point1.y, point2.x, point2.y);
- let lastDY = point1.y;
+ const baselineY = getLinearBaseline(ps);
return d3.area()
.x((d) => xt(d.x))
- .y0((d, index) => {
- if (index > 0) {
- const lastD = ps[index - 1];
- const y = slope * (d.x - lastD.x) + lastDY;
- lastDY = y;
- return yt(y);
- }
- return yt(0);
- })
+ .y0((d) => yt(baselineY(d)))
.y1((d) => yt(d.y))(ps);
};
@@ -295,8 +398,10 @@ class LineFocus {
.style('fill', 'red');
d3.select(`#auc${itgIdTag(d)}`)
.style('fill-opacity', 0.2);
+ this.clearSplitPreview();
})
- .on('click', (event, d) => this.onClickTarget(event, d));
+ .on('mousemove', (event, d) => this.onIntegrationMouseMove(event, d, shift, true))
+ .on('click', (event, d) => this.onClickIntegrationTarget(event, d));
}
drawPeaks(editPeakSt) {
@@ -394,12 +499,23 @@ class LineFocus {
const isDisable = Cfg.btnCmdIntg(this.layout);
const ignoreRef = Format.isHplcUvVisLayout(this.layout);
const itgs = isDisable ? [] : stack;
+ Object.assign(this, {
+ integrationSplitTargets: { stack: itgs, shift, ignoreRef },
+ });
- const igbp = this.tags.igbPath.selectAll('path').data(itgs);
+ const igGroups = getVisualSplitGroups(itgs).map((group) => ({
+ xL: group.xL,
+ xU: group.xU,
+ isMerged: group.isMerged,
+ groupId: group.groupId,
+ target: group.items[0],
+ }));
+
+ const igbp = this.tags.igbPath.selectAll('path').data(igGroups);
igbp.exit()
.attr('class', 'exit')
.remove();
- const igcp = this.tags.igcPath.selectAll('path').data(itgs);
+ const igcp = this.tags.igcPath.selectAll('path').data(igGroups);
igcp.exit()
.attr('class', 'exit')
.remove();
@@ -416,11 +532,12 @@ class LineFocus {
.attr('class', 'exit')
.remove();
auc.merge(auc);
+ this.drawVisualSplitLines([], shift, ignoreRef);
return;
}
if (ignoreRef) {
- this.drawAUC(stack);
+ this.drawAUC(stack, shift);
} else {
// rescale for zoom
const { xt } = TfRescale(this);
@@ -461,8 +578,10 @@ class LineFocus {
.attr('stroke', '#228B22');
d3.select(`#igtp${itgIdTag(d)}`)
.style('fill', '#228B22');
+ this.clearSplitPreview();
})
- .on('click', (event, d) => this.onClickTarget(event, d));
+ .on('mousemove', (event, d) => this.onIntegrationMouseMove(event, d, shift, ignoreRef))
+ .on('click', (event, d) => this.onClickIntegrationTarget(event, d));
const integCurve = (border) => {
const { xL, xU } = border;
@@ -505,8 +624,10 @@ class LineFocus {
.attr('stroke', '#228B22');
d3.select(`#igtp${itgIdTag(d)}`)
.style('fill', '#228B22');
+ this.clearSplitPreview();
})
- .on('click', (event, d) => this.onClickTarget(event, d));
+ .on('mousemove', (event, d) => this.onIntegrationMouseMove(event, d, shift, ignoreRef))
+ .on('click', (event, d) => this.onClickIntegrationTarget(event, d));
igtp.enter()
.append('text')
@@ -534,9 +655,12 @@ class LineFocus {
.attr('stroke', '#228B22');
d3.select(`#igtp${itgIdTag(d)}`)
.style('fill', '#228B22');
+ this.clearSplitPreview();
})
- .on('click', (event, d) => this.onClickTarget(event, d));
+ .on('mousemove', (event, d) => this.onIntegrationMouseMove(event, d, shift, ignoreRef))
+ .on('click', (event, d) => this.onClickIntegrationTarget(event, d));
}
+ this.drawVisualSplitLines(itgs, shift, ignoreRef);
}
drawMtply(mtplySt) {
@@ -793,7 +917,7 @@ class LineFocus {
create({
filterSeed, filterPeak, tTrEndPts, tSfPeaks, freq, comparisons,
editPeakSt, layoutSt, integationSt, mtplySt,
- sweepExtentSt, isUiAddIntgSt, isUiNoBrushSt,
+ sweepExtentSt, isUiAddIntgSt, isUiSplitIntgSt, isUiVisualSplitIntgSt, isUiNoBrushSt,
wavelength,
}) {
this.svg = d3.select('.d3Svg');
@@ -804,6 +928,8 @@ class LineFocus {
this.scales = InitScale(this, this.reverseXAxis(layoutSt));
this.setTip();
this.setDataParams(filterSeed, filterPeak, tTrEndPts, tSfPeaks, freq, layoutSt, wavelength);
+ Object.assign(this, { isUiSplitIntgSt, isUiVisualSplitIntgSt });
+ if (!isUiSplitIntgSt && !isUiVisualSplitIntgSt) this.clearSplitPreview();
MountCompass(this);
this.axis = MountAxis(this);
@@ -833,12 +959,14 @@ class LineFocus {
update({
filterSeed, filterPeak, tTrEndPts, tSfPeaks, freq, comparisons,
editPeakSt, layoutSt, integationSt, mtplySt,
- sweepExtentSt, isUiAddIntgSt, isUiNoBrushSt,
+ sweepExtentSt, isUiAddIntgSt, isUiSplitIntgSt, isUiVisualSplitIntgSt, isUiNoBrushSt,
wavelength,
}) {
this.root = d3.select(this.rootKlass).selectAll('.focus-main');
this.scales = InitScale(this, this.reverseXAxis(layoutSt));
this.setDataParams(filterSeed, filterPeak, tTrEndPts, tSfPeaks, freq, layoutSt, wavelength);
+ Object.assign(this, { isUiSplitIntgSt, isUiVisualSplitIntgSt });
+ if (!isUiSplitIntgSt && !isUiVisualSplitIntgSt) this.clearSplitPreview();
if (this.data && this.data.length > 0) {
this.setConfig(sweepExtentSt);
diff --git a/src/components/d3_multi/index.js b/src/components/d3_multi/index.js
index d95c8928..573ab341 100644
--- a/src/components/d3_multi/index.js
+++ b/src/components/d3_multi/index.js
@@ -12,7 +12,10 @@ import {
import Format from '../../helpers/format';
import { resetAll } from '../../actions/manager';
import { selectUiSweep, scrollUiWheel, clickUiTarget } from '../../actions/ui';
-import { LIST_NON_BRUSH_TYPES } from '../../constants/list_ui';
+import {
+ addVisualSplitLine, removeVisualSplitLine, splitIntegration,
+} from '../../actions/integration';
+import { LIST_UI_SWEEP_TYPE, LIST_NON_BRUSH_TYPES } from '../../constants/list_ui';
import { addNewCylicVoltaPairPeak, addCylicVoltaMaxPeak, addCylicVoltaMinPeak } from '../../actions/cyclic_voltammetry';
import MultiFocus from './multi_focus';
@@ -29,7 +32,8 @@ class ViewerMulti extends React.Component {
super(props);
const {
- entities, clickUiTargetAct, selectUiSweepAct, scrollUiWheelAct,
+ entities, clickUiTargetAct, selectUiSweepAct, scrollUiWheelAct, splitIntegrationAct,
+ addVisualSplitLineAct, removeVisualSplitLineAct,
} = this.props;
this.rootKlass = '.d3Line';
this.containerRef = React.createRef();
@@ -37,21 +41,31 @@ class ViewerMulti extends React.Component {
this.resizeObserver = null;
this.focus = new MultiFocus({
- W, H, entities, clickUiTargetAct, selectUiSweepAct, scrollUiWheelAct,
+ W,
+ H,
+ entities,
+ clickUiTargetAct,
+ selectUiSweepAct,
+ scrollUiWheelAct,
+ splitIntegrationAct,
+ addVisualSplitLineAct,
+ removeVisualSplitLineAct,
});
this.normChange = this.normChange.bind(this);
this.handleResize = this.handleResize.bind(this);
+ this.syncFocusActions = this.syncFocusActions.bind(this);
}
componentDidMount() {
+ this.syncFocusActions();
this.renderChart(this.props, true);
this.setupResizeObserver();
const {
curveSt,
seed, peak, cLabel, xLabel, yLabel, feature,
tTrEndPts, tSfPeaks, editPeakSt, layoutSt,
- sweepExtentSt, isUiNoBrushSt,
+ sweepExtentSt, isUiAddIntgSt, isUiSplitIntgSt, isUiVisualSplitIntgSt, isUiNoBrushSt,
isHidden, resetAllAct, cyclicvoltaSt,
integationSt, mtplySt, axesUnitsSt,
} = this.props;
@@ -93,6 +107,9 @@ class ViewerMulti extends React.Component {
editPeakSt,
layoutSt,
sweepExtentSt,
+ isUiAddIntgSt,
+ isUiSplitIntgSt,
+ isUiVisualSplitIntgSt,
isUiNoBrushSt,
cyclicvoltaSt,
integationSt,
@@ -108,10 +125,11 @@ class ViewerMulti extends React.Component {
entities, curveSt,
seed, peak, cLabel, xLabel, yLabel,
tTrEndPts, tSfPeaks, editPeakSt, layoutSt,
- sweepExtentSt, isUiNoBrushSt,
+ sweepExtentSt, isUiAddIntgSt, isUiSplitIntgSt, isUiVisualSplitIntgSt, isUiNoBrushSt,
isHidden, cyclicvoltaSt,
integationSt, mtplySt, axesUnitsSt,
} = this.props;
+ this.syncFocusActions();
this.normChange(prevProps);
let xxLabel = xLabel;
@@ -151,6 +169,9 @@ class ViewerMulti extends React.Component {
editPeakSt,
layoutSt,
sweepExtentSt,
+ isUiAddIntgSt,
+ isUiSplitIntgSt,
+ isUiVisualSplitIntgSt,
isUiNoBrushSt,
cyclicvoltaSt,
integationSt,
@@ -201,6 +222,22 @@ class ViewerMulti extends React.Component {
this.resizeObserver.observe(this.containerRef.current);
}
+ syncFocusActions() {
+ if (!this.focus) return;
+ const {
+ clickUiTargetAct, selectUiSweepAct, scrollUiWheelAct,
+ splitIntegrationAct, addVisualSplitLineAct, removeVisualSplitLineAct,
+ } = this.props;
+ Object.assign(this.focus, {
+ clickUiTargetAct,
+ selectUiSweepAct,
+ scrollUiWheelAct,
+ splitIntegrationAct,
+ addVisualSplitLineAct,
+ removeVisualSplitLineAct,
+ });
+ }
+
teardownResizeObserver() {
if (this.resizeObserver) {
this.resizeObserver.disconnect();
@@ -221,10 +258,10 @@ class ViewerMulti extends React.Component {
curveSt,
seed, peak, cLabel, xLabel, yLabel, feature,
tTrEndPts, tSfPeaks, editPeakSt, layoutSt,
- sweepExtentSt, isUiNoBrushSt,
+ sweepExtentSt, isUiAddIntgSt, isUiSplitIntgSt, isUiNoBrushSt,
isHidden, resetAllAct, cyclicvoltaSt,
integationSt, mtplySt, axesUnitsSt,
- entities, clickUiTargetAct, selectUiSweepAct, scrollUiWheelAct,
+ entities, clickUiTargetAct, selectUiSweepAct, scrollUiWheelAct, splitIntegrationAct,
} = props;
const size = this.getTargetSize(layoutSt);
@@ -260,6 +297,7 @@ class ViewerMulti extends React.Component {
clickUiTargetAct,
selectUiSweepAct,
scrollUiWheelAct,
+ splitIntegrationAct,
});
drawMain(this.rootKlass, size.width, size.height);
@@ -272,6 +310,8 @@ class ViewerMulti extends React.Component {
editPeakSt,
layoutSt,
sweepExtentSt,
+ isUiAddIntgSt,
+ isUiSplitIntgSt,
isUiNoBrushSt,
cyclicvoltaSt,
integationSt,
@@ -305,6 +345,9 @@ const mapStateToProps = (state, props) => (
editPeakSt: state.editPeak.present,
layoutSt: state.layout,
sweepExtentSt: state.ui.sweepExtent,
+ isUiAddIntgSt: state.ui.sweepType === LIST_UI_SWEEP_TYPE.INTEGRATION_ADD,
+ isUiSplitIntgSt: state.ui.sweepType === LIST_UI_SWEEP_TYPE.INTEGRATION_SPLIT,
+ isUiVisualSplitIntgSt: state.ui.sweepType === LIST_UI_SWEEP_TYPE.INTEGRATION_VISUAL_SPLIT,
isUiNoBrushSt: LIST_NON_BRUSH_TYPES.indexOf(state.ui.sweepType) < 0,
cyclicvoltaSt: state.cyclicvolta,
maxminPeakSt: Feature2MaxMinPeak(state, props),
@@ -320,6 +363,9 @@ const mapDispatchToProps = (dispatch) => (
clickUiTargetAct: clickUiTarget,
selectUiSweepAct: selectUiSweep,
scrollUiWheelAct: scrollUiWheel,
+ splitIntegrationAct: splitIntegration,
+ addVisualSplitLineAct: addVisualSplitLine,
+ removeVisualSplitLineAct: removeVisualSplitLine,
addNewCylicVoltaPairPeakAct: addNewCylicVoltaPairPeak,
addCylicVoltaMaxPeakAct: addCylicVoltaMaxPeak,
addCylicVoltaMinPeakAct: addCylicVoltaMinPeak,
@@ -341,11 +387,17 @@ ViewerMulti.propTypes = {
integationSt: PropTypes.object.isRequired,
mtplySt: PropTypes.object.isRequired,
sweepExtentSt: PropTypes.object.isRequired,
+ isUiAddIntgSt: PropTypes.bool.isRequired,
+ isUiSplitIntgSt: PropTypes.bool.isRequired,
+ isUiVisualSplitIntgSt: PropTypes.bool.isRequired,
isUiNoBrushSt: PropTypes.bool.isRequired,
resetAllAct: PropTypes.func.isRequired,
clickUiTargetAct: PropTypes.func.isRequired,
selectUiSweepAct: PropTypes.func.isRequired,
scrollUiWheelAct: PropTypes.func.isRequired,
+ splitIntegrationAct: PropTypes.func.isRequired,
+ addVisualSplitLineAct: PropTypes.func.isRequired,
+ removeVisualSplitLineAct: PropTypes.func.isRequired,
isHidden: PropTypes.bool,
cyclicvoltaSt: PropTypes.object.isRequired,
maxminPeakSt: PropTypes.object,
diff --git a/src/components/d3_multi/multi_focus.js b/src/components/d3_multi/multi_focus.js
index 22a76a34..e44423f5 100644
--- a/src/components/d3_multi/multi_focus.js
+++ b/src/components/d3_multi/multi_focus.js
@@ -11,6 +11,15 @@ import {
import { PksEdit, PeckersEdit } from '../../helpers/converter';
import MountBrush from '../../helpers/brush';
import { TfRescale, MountCompass } from '../../helpers/compass';
+import {
+ clearIntegrationSplitPreview,
+ drawIntegrationSplitPreview,
+ drawIntegrationVisualSplitLines,
+ getSplitXFromEvent,
+ getVisualSplitLineAtX,
+ isAlreadyVisuallySplit,
+ isMergedVisualSplitGroup,
+} from '../../helpers/integration_split';
import { LIST_LAYOUT } from '../../constants/list_layout';
import Format from '../../helpers/format';
import {
@@ -18,9 +27,10 @@ import {
} from '../../helpers/chem';
import Cfg from '../../helpers/cfg';
import { itgIdTag, mpyIdTag } from '../../helpers/focus';
-import { calcArea } from '../../helpers/integration';
+import {
+ calcArea, getIntegrationPoints, getLinearBaseline, getVisualSplitGroups,
+} from '../../helpers/integration';
import { calcMpyCenter } from '../../helpers/multiplicity_calc';
-import { calcSlope } from '../../helpers/calc';
const d3 = require('d3');
@@ -28,6 +38,7 @@ class MultiFocus {
constructor(props) {
const {
W, H, clickUiTargetAct, selectUiSweepAct, scrollUiWheelAct, entities,
+ splitIntegrationAct, addVisualSplitLineAct, removeVisualSplitLineAct,
} = props;
this.entities = entities;
@@ -45,6 +56,9 @@ class MultiFocus {
this.clickUiTargetAct = clickUiTargetAct;
this.selectUiSweepAct = selectUiSweepAct;
this.scrollUiWheelAct = scrollUiWheelAct;
+ this.splitIntegrationAct = splitIntegrationAct;
+ this.addVisualSplitLineAct = addVisualSplitLineAct;
+ this.removeVisualSplitLineAct = removeVisualSplitLineAct;
this.brush = d3.brush();
this.brushX = d3.brushX();
@@ -72,6 +86,11 @@ class MultiFocus {
this.shouldUpdate = {};
// this.freq = false;
this.layout = LIST_LAYOUT.CYCLIC_VOLTAMMETRY;
+ this.isUiAddIntgSt = false;
+ this.isUiSplitIntgSt = false;
+ this.isUiVisualSplitIntgSt = false;
+ this.integrationSplitTargets = null;
+ this.firstIntegrationPoint = null;
this.getShouldUpdate = this.getShouldUpdate.bind(this);
this.resetShouldUpdate = this.resetShouldUpdate.bind(this);
@@ -90,6 +109,11 @@ class MultiFocus {
this.drawMtply = this.drawMtply.bind(this);
this.drawAUC = this.drawAUC.bind(this);
this.onClickTarget = this.onClickTarget.bind(this);
+ this.onClickIntegrationTarget = this.onClickIntegrationTarget.bind(this);
+ this.onClickVisualSplitLine = this.onClickVisualSplitLine.bind(this);
+ this.onIntegrationMouseMove = this.onIntegrationMouseMove.bind(this);
+ this.clearSplitPreview = this.clearSplitPreview.bind(this);
+ this.drawVisualSplitLines = this.drawVisualSplitLines.bind(this);
this.mergedPeaks = this.mergedPeaks.bind(this);
this.setDataPecker = this.setDataPecker.bind(this);
this.drawPeckers = this.drawPeckers.bind(this);
@@ -338,6 +362,89 @@ class MultiFocus {
}
}
+ clearSplitPreview() {
+ clearIntegrationSplitPreview(this);
+ }
+
+ onIntegrationMouseMove(event, data, shift, ignoreRef) {
+ if (!this.isUiSplitIntgSt && !this.isUiVisualSplitIntgSt) return;
+ if (this.isUiVisualSplitIntgSt && isAlreadyVisuallySplit(data)) {
+ this.clearSplitPreview();
+ return;
+ }
+ if (this.isUiSplitIntgSt && isMergedVisualSplitGroup(data)) {
+ this.clearSplitPreview();
+ return;
+ }
+ const splitX = getSplitXFromEvent(event, this);
+ drawIntegrationSplitPreview(this, data, splitX, shift, ignoreRef);
+ }
+
+ onClickIntegrationTarget(event, data) {
+ if (!this.isUiSplitIntgSt && !this.isUiVisualSplitIntgSt) {
+ this.onClickTarget(event, data);
+ return;
+ }
+
+ event.stopPropagation();
+ event.preventDefault();
+ const splitX = getSplitXFromEvent(event, this);
+ this.clearSplitPreview();
+ if (this.isUiVisualSplitIntgSt) {
+ const { stack = [], shift = 0 } = this.integrationSplitTargets || {};
+ const existingSplitX = getVisualSplitLineAtX(this, stack, splitX, shift);
+ if (Number.isFinite(existingSplitX)) {
+ if (typeof this.removeVisualSplitLineAct !== 'function') return;
+ this.removeVisualSplitLineAct({
+ curveIdx: this.jcampIdx,
+ splitX: existingSplitX,
+ data: this.data,
+ });
+ return;
+ }
+ if (isAlreadyVisuallySplit(data)) return;
+ if (typeof this.addVisualSplitLineAct !== 'function') return;
+ this.addVisualSplitLineAct({
+ curveIdx: this.jcampIdx,
+ target: data,
+ splitX,
+ data: this.data,
+ });
+ return;
+ }
+
+ if (isMergedVisualSplitGroup(data)) return;
+ this.splitIntegrationAct({
+ curveIdx: this.jcampIdx,
+ target: data,
+ splitX,
+ data: this.data,
+ });
+ }
+
+ onClickVisualSplitLine(event, splitX) {
+ event.stopPropagation();
+ event.preventDefault();
+ this.clearSplitPreview();
+ if (typeof this.removeVisualSplitLineAct !== 'function') return;
+ this.removeVisualSplitLineAct({
+ curveIdx: this.jcampIdx,
+ splitX,
+ data: this.data,
+ });
+ }
+
+ drawVisualSplitLines(stack, shift, ignoreRef) {
+ drawIntegrationVisualSplitLines(
+ this,
+ stack,
+ shift,
+ ignoreRef,
+ this.isUiVisualSplitIntgSt,
+ this.onClickVisualSplitLine,
+ );
+ }
+
onClickPecker(event, data) {
event.stopPropagation();
event.preventDefault();
@@ -371,34 +478,30 @@ class MultiFocus {
return this.dataPeckers;
}
- drawAUC(stack) {
+ drawAUC(stack, shift = 0) {
const { xt, yt } = TfRescale(this);
- const auc = this.tags.aucPath.selectAll('path').data(stack);
+ const groups = getVisualSplitGroups(stack).map((group) => ({
+ xL: group.xL,
+ xU: group.xU,
+ isMerged: group.isMerged,
+ groupId: group.groupId,
+ target: group.items[0],
+ }));
+ const auc = this.tags.aucPath.selectAll('path').data(groups);
auc.exit()
.attr('class', 'exit')
.remove();
const integCurve = (border) => {
const { xL, xU } = border;
- const ps = this.data.filter((d) => d.x > xL && d.x < xU);
+ const ps = getIntegrationPoints(xL - shift, xU - shift, this.data);
if (!ps[0]) return null;
- const point1 = ps[0];
- const point2 = ps[ps.length - 1];
- const slope = calcSlope(point1.x, point1.y, point2.x, point2.y);
- let lastDY = point1.y;
+ const baselineY = getLinearBaseline(ps);
return d3.area()
.x((d) => xt(d.x))
- .y0((d, index) => {
- if (index > 0) {
- const lastD = ps[index - 1];
- const y = slope * (d.x - lastD.x) + lastDY;
- lastDY = y;
- return yt(y);
- }
- return yt(0);
- })
+ .y0((d) => yt(baselineY(d)))
.y1((d) => yt(d.y))(ps);
};
@@ -427,8 +530,10 @@ class MultiFocus {
.style('fill', 'red');
d3.select(`#auc${itgIdTag(d)}`)
.style('fill-opacity', 0.2);
+ this.clearSplitPreview();
})
- .on('click', (event, d) => this.onClickTarget(event, d));
+ .on('mousemove', (event, d) => this.onIntegrationMouseMove(event, d, shift, true))
+ .on('click', (event, d) => this.onClickIntegrationTarget(event, d));
}
drawPeaks(editPeakSt) {
@@ -612,6 +717,9 @@ class MultiFocus {
const { integrations } = integationSt;
const selectedIntegration = integrations[this.jcampIdx];
if (selectedIntegration === false || selectedIntegration === undefined) {
+ Object.assign(this, {
+ integrationSplitTargets: { stack: [], shift: 0, ignoreRef: false },
+ });
const itgs = [];
const igbp = this.tags.igbPath.selectAll('path').data(itgs);
igbp.exit()
@@ -626,6 +734,7 @@ class MultiFocus {
igtp.exit()
.attr('class', 'exit')
.remove();
+ this.drawVisualSplitLines([], 0, false);
return;
}
@@ -636,12 +745,23 @@ class MultiFocus {
const isDisable = Cfg.btnCmdIntg(this.layout);
const ignoreRef = Format.isHplcUvVisLayout(this.layout);
const itgs = isDisable ? [] : stack;
+ Object.assign(this, {
+ integrationSplitTargets: { stack: itgs, shift, ignoreRef },
+ });
+
+ const igGroups = getVisualSplitGroups(itgs).map((group) => ({
+ xL: group.xL,
+ xU: group.xU,
+ isMerged: group.isMerged,
+ groupId: group.groupId,
+ target: group.items[0],
+ }));
- const igbp = this.tags.igbPath.selectAll('path').data(itgs);
+ const igbp = this.tags.igbPath.selectAll('path').data(igGroups);
igbp.exit()
.attr('class', 'exit')
.remove();
- const igcp = this.tags.igcPath.selectAll('path').data(itgs);
+ const igcp = this.tags.igcPath.selectAll('path').data(igGroups);
igcp.exit()
.attr('class', 'exit')
.remove();
@@ -658,11 +778,12 @@ class MultiFocus {
.attr('class', 'exit')
.remove();
auc.merge(auc);
+ this.drawVisualSplitLines([], shift, ignoreRef);
return;
}
if (ignoreRef) {
- this.drawAUC(stack);
+ this.drawAUC(stack, shift);
} else {
// rescale for zoom
const { xt } = TfRescale(this);
@@ -703,8 +824,10 @@ class MultiFocus {
.attr('stroke', '#228B22');
d3.select(`#igtp${itgIdTag(d)}`)
.style('fill', '#228B22');
+ this.clearSplitPreview();
})
- .on('click', (event, d) => this.onClickTarget(event, d));
+ .on('mousemove', (event, d) => this.onIntegrationMouseMove(event, d, shift, ignoreRef))
+ .on('click', (event, d) => this.onClickIntegrationTarget(event, d));
const integCurve = (border) => {
const { xL, xU } = border;
@@ -747,8 +870,10 @@ class MultiFocus {
.attr('stroke', '#228B22');
d3.select(`#igtp${itgIdTag(d)}`)
.style('fill', '#228B22');
+ this.clearSplitPreview();
})
- .on('click', (event, d) => this.onClickTarget(event, d));
+ .on('mousemove', (event, d) => this.onIntegrationMouseMove(event, d, shift, ignoreRef))
+ .on('click', (event, d) => this.onClickIntegrationTarget(event, d));
igtp.enter()
.append('text')
@@ -776,9 +901,12 @@ class MultiFocus {
.attr('stroke', '#228B22');
d3.select(`#igtp${itgIdTag(d)}`)
.style('fill', '#228B22');
+ this.clearSplitPreview();
})
- .on('click', (event, d) => this.onClickTarget(event, d));
+ .on('mousemove', (event, d) => this.onIntegrationMouseMove(event, d, shift, ignoreRef))
+ .on('click', (event, d) => this.onClickIntegrationTarget(event, d));
}
+ this.drawVisualSplitLines(itgs, shift, ignoreRef);
}
drawMtply(mtplySt) {
@@ -1050,7 +1178,7 @@ class MultiFocus {
curveSt,
filterSeed, filterPeak, tTrEndPts, tSfPeaks,
editPeakSt, layoutSt,
- sweepExtentSt, isUiNoBrushSt,
+ sweepExtentSt, isUiAddIntgSt, isUiSplitIntgSt, isUiVisualSplitIntgSt, isUiNoBrushSt,
cyclicvoltaSt,
integationSt, mtplySt,
}) {
@@ -1066,6 +1194,8 @@ class MultiFocus {
this.scales = InitScale(this, this.reverseXAxis(layoutSt));
this.setTip();
this.setDataParams(filterSeed, filterPeak, tTrEndPts, tSfPeaks, layoutSt, cyclicvoltaSt, jcampIdx);
+ Object.assign(this, { isUiSplitIntgSt, isUiVisualSplitIntgSt });
+ if (!isUiSplitIntgSt && !isUiVisualSplitIntgSt) this.clearSplitPreview();
MountCompass(this);
this.axis = MountAxis(this);
@@ -1089,7 +1219,7 @@ class MultiFocus {
this.drawInteg(integationSt);
this.drawMtply(mtplySt);
}
- MountBrush(this, false, isUiNoBrushSt);
+ MountBrush(this, isUiAddIntgSt, isUiNoBrushSt);
this.resetShouldUpdate(editPeakSt);
}
@@ -1097,7 +1227,7 @@ class MultiFocus {
entities, curveSt,
filterSeed, filterPeak, tTrEndPts, tSfPeaks,
editPeakSt, layoutSt,
- sweepExtentSt, isUiNoBrushSt, cyclicvoltaSt,
+ sweepExtentSt, isUiAddIntgSt, isUiSplitIntgSt, isUiVisualSplitIntgSt, isUiNoBrushSt, cyclicvoltaSt,
integationSt, mtplySt,
}) {
this.root = d3.select(this.rootKlass).selectAll('.focus-main');
@@ -1109,6 +1239,8 @@ class MultiFocus {
this.entities = entities;
this.setDataParams(filterSeed, filterPeak, tTrEndPts, tSfPeaks, layoutSt, cyclicvoltaSt, jcampIdx);
+ Object.assign(this, { isUiSplitIntgSt, isUiVisualSplitIntgSt });
+ if (!isUiSplitIntgSt && !isUiVisualSplitIntgSt) this.clearSplitPreview();
if (this.data && this.data.length > 0) {
this.setConfig(sweepExtentSt);
@@ -1123,7 +1255,7 @@ class MultiFocus {
this.drawInteg(integationSt);
this.drawMtply(mtplySt);
}
- MountBrush(this, false, isUiNoBrushSt);
+ MountBrush(this, isUiAddIntgSt, isUiNoBrushSt);
this.resetShouldUpdate(editPeakSt);
}
}
diff --git a/src/components/d3_rect/rect_focus.js b/src/components/d3_rect/rect_focus.js
index 650c3370..a33d364f 100644
--- a/src/components/d3_rect/rect_focus.js
+++ b/src/components/d3_rect/rect_focus.js
@@ -51,6 +51,8 @@ class RectFocus {
this.factor = 0.125;
this.currentExtent = null;
this.layout = LIST_LAYOUT.MS;
+ this.isUiAddIntgSt = false;
+ this.firstIntegrationPoint = null;
this.setTip = this.setTip.bind(this);
this.setDataParams = this.setDataParams.bind(this);
diff --git a/src/components/panel/graph_selection.js b/src/components/panel/graph_selection.js
index ab65afa2..56f2054b 100644
--- a/src/components/panel/graph_selection.js
+++ b/src/components/panel/graph_selection.js
@@ -55,12 +55,13 @@ const GraphSelectionPanel = ({
if (subLayoutsInfo) {
subLayoutValues = Object.keys(subLayoutsInfo);
}
+ const subLayoutKey = subLayoutValues.join('|');
const [selectedSubLayout, setSelectedSublayout] = useState(subLayoutValues[0]);
useEffect(() => {
setSelectedSublayout(subLayoutValues[0]);
- }, subLayoutValues);
+ }, [subLayoutKey]);
if (!curveSt) {
return ();
diff --git a/src/constants/action_type.js b/src/constants/action_type.js
index 1781efa7..29c0bb9a 100644
--- a/src/constants/action_type.js
+++ b/src/constants/action_type.js
@@ -88,6 +88,9 @@ const INTEGRATION = {
RESET_ALL_RDC: 'INTEGRATION_RESET_ALL_RDC',
CLEAR_ALL: 'INTEGRATION_CLEAR_ALL',
SWEEP: 'INTEGRATION_SWEEP',
+ SPLIT: 'INTEGRATION_SPLIT',
+ ADD_VISUAL_SPLIT: 'INTEGRATION_ADD_VISUAL_SPLIT',
+ RM_VISUAL_SPLIT: 'INTEGRATION_RM_VISUAL_SPLIT',
};
const SIMULATION = {
diff --git a/src/constants/list_ui.js b/src/constants/list_ui.js
index c8aab9bd..f3ad16f0 100644
--- a/src/constants/list_ui.js
+++ b/src/constants/list_ui.js
@@ -10,6 +10,8 @@ const LIST_UI_SWEEP_TYPE = {
INTEGRATION_RM: 'integration remove',
INTEGRATION_REF: 'integration reference',
INTEGRATION_SET_REF: 'integration set ref',
+ INTEGRATION_SPLIT: 'integration split',
+ INTEGRATION_VISUAL_SPLIT: 'integration visual split',
MULTIPLICITY_SWEEP_ADD: 'multiplicity sweep add',
MULTIPLICITY_ONE_CLICK: 'multiplicity one click',
MULTIPLICITY_ONE_RM: 'multiplicity one remove',
@@ -34,6 +36,8 @@ const LIST_NON_BRUSH_TYPES = [
LIST_UI_SWEEP_TYPE.ANCHOR_SHIFT,
LIST_UI_SWEEP_TYPE.INTEGRATION_RM,
LIST_UI_SWEEP_TYPE.INTEGRATION_SET_REF,
+ LIST_UI_SWEEP_TYPE.INTEGRATION_SPLIT,
+ LIST_UI_SWEEP_TYPE.INTEGRATION_VISUAL_SPLIT,
LIST_UI_SWEEP_TYPE.MULTIPLICITY_PEAK_ADD,
LIST_UI_SWEEP_TYPE.MULTIPLICITY_PEAK_RM,
LIST_UI_SWEEP_TYPE.MULTIPLICITY_ONE_CLICK,
diff --git a/src/helpers/brush.js b/src/helpers/brush.js
index e4e63e5d..4b4f36db 100644
--- a/src/helpers/brush.js
+++ b/src/helpers/brush.js
@@ -1,9 +1,16 @@
/* eslint-disable prefer-object-spread */
-import { MouseMove } from './compass';
+import { clearIntegrationPreview, MouseMove } from './compass';
+import { clearPendingIntegrationDraft } from './integration_draft.js'; // eslint-disable-line import/extensions
+import { buildSweepPayloadFromXBounds } from './sweep.js'; // eslint-disable-line import/extensions
const d3 = require('d3');
+const selectBrushLayer = (focus, selector) => {
+ const svg = focus.svg || d3.select('.d3Svg');
+ return svg.selectAll(selector);
+};
+
const wheeled = (focus, event) => {
const { currentExtent, scrollUiWheelAct } = focus;
// WORKAROUND: firefox wheel compatibilty
@@ -14,7 +21,7 @@ const wheeled = (focus, event) => {
const brushed = (focus, isUiAddIntgSt, event) => {
const {
- selectUiSweepAct, data, dataPks, brush, w, h, scales,
+ selectUiSweepAct, data, dataPks, brush, brushX, w, h, scales,
} = focus;
const selection = event.selection && event.selection.reverse();
if (!selection) return;
@@ -23,53 +30,60 @@ const brushed = (focus, isUiAddIntgSt, event) => {
let xExtent = { xL: xes[0], xU: xes[1] };
let yExtent = { yL: yes[0], yU: yes[1] };
if (isUiAddIntgSt) {
- xes = selection.map(scales.x.invert).sort((a, b) => a - b);
- xExtent = { xL: xes[0], xU: xes[1] };
- } else {
- const [begPt, endPt] = selection;
- xes = [begPt[0], endPt[0]].map(scales.x.invert).sort((a, b) => a - b);
- yes = [begPt[1], endPt[1]].map(scales.y.invert).sort((a, b) => a - b);
- xExtent = { xL: xes[0], xU: xes[1] };
- yExtent = { yL: yes[0], yU: yes[1] };
+ const payload = buildSweepPayloadFromXBounds(
+ focus,
+ scales.x.invert(selection[0]),
+ scales.x.invert(selection[1]),
+ );
+ selectUiSweepAct(payload);
+ if (brushX) {
+ selectBrushLayer(focus, '.brushX').call(brushX.move, null);
+ }
+ return;
}
+ const [begPt, endPt] = selection;
+ xes = [begPt[0], endPt[0]].map(scales.x.invert).sort((a, b) => a - b);
+ yes = [begPt[1], endPt[1]].map(scales.y.invert).sort((a, b) => a - b);
+ xExtent = { xL: xes[0], xU: xes[1] };
+ yExtent = { yL: yes[0], yU: yes[1] };
selectUiSweepAct({
xExtent, yExtent, data, dataPks,
});
- d3.select('.d3Svg').selectAll('.brush').call(brush.move, null);
+ selectBrushLayer(focus, '.brush').call(brush.move, null);
};
const MountBrush = (focus, isUiAddIntgSt, isUiNoBrushSt) => {
const {
- root, svg, brush, brushX, w, h,
+ root, svg, brush, w, h,
} = focus;
svg.selectAll('.brush').remove();
svg.selectAll('.brushX').remove();
+ Object.assign(focus, { isUiAddIntgSt });
+ const { firstIntegrationPoint, data, jcampIdx } = focus;
+ const isSameIntegrationDraft = firstIntegrationPoint
+ && firstIntegrationPoint.jcampIdx === jcampIdx
+ && firstIntegrationPoint.dataLength === data.length;
+ if (!isUiAddIntgSt || (firstIntegrationPoint && !isSameIntegrationDraft)) {
+ clearPendingIntegrationDraft();
+ Object.assign(focus, { firstIntegrationPoint: null });
+ clearIntegrationPreview(focus);
+ }
const brushedCb = (event) => brushed(focus, isUiAddIntgSt, event);
const wheeledCb = (event) => wheeled(focus, event);
- if (isUiNoBrushSt) {
- const target = isUiAddIntgSt ? brushX : brush;
- target.handleSize(10)
+ if (isUiNoBrushSt && !isUiAddIntgSt) {
+ brush.handleSize(10)
.extent([[0, 0], [w, h]])
.on('end', brushedCb);
- // append brush components
- const klass = isUiAddIntgSt ? 'brushX' : 'brush';
root.append('g')
- .attr('class', klass)
+ .attr('class', 'brush')
.on('mousemove', (event) => MouseMove(event, focus))
- .call(target);
+ .call(brush);
}
svg.on('wheel', wheeledCb);
};
export default MountBrush;
-
-// const resetedCb = () => reseted(main);
-// main.svg.on('dblclick', resetedCb);
-// const reseted = (main) => {
-// const { selectUiSweepAct } = main;
-// selectUiSweepAct({ xExtent: false, yExtent: false });
-// };
diff --git a/src/helpers/chem.js b/src/helpers/chem.js
index 491a1529..16dca3f2 100644
--- a/src/helpers/chem.js
+++ b/src/helpers/chem.js
@@ -511,20 +511,42 @@ const calcIntgRefArea = (spectra, stack) => {
return { raw2realRatio };
};
+const parseObservedIntegralGroups = (rawValue) => {
+ if (!rawValue) return {};
+ const tokenRegx = /[^A-Za-z0-9._-]/g;
+ const groupsByIdx = {};
+ rawValue.split('\n').forEach((line) => {
+ const cells = line.split(',').map((c) => c.replace(tokenRegx, ''));
+ if (cells.length < 2) return;
+ const idx = parseInt(cells[0], 10);
+ const groupId = cells[1];
+ if (!Number.isInteger(idx) || idx < 0 || !groupId) return;
+ groupsByIdx[idx] = groupId;
+ });
+ return groupsByIdx;
+};
+
const buildIntegFeature = (jcamp, spectra) => {
- const { $OBSERVEDINTEGRALS, $OBSERVEDMULTIPLETS } = jcamp.info;
+ const {
+ $OBSERVEDINTEGRALS, $OBSERVEDMULTIPLETS, $OBSERVEDINTEGRALSGROUPS,
+ } = jcamp.info;
const regx = /[^0-9.,-]/g;
let stack = [];
if ($OBSERVEDINTEGRALS) {
const its = $OBSERVEDINTEGRALS.split('\n').slice(1);
- const itStack = its.map((t) => {
+ const groupsByIdx = parseObservedIntegralGroups($OBSERVEDINTEGRALSGROUPS);
+ const itStack = its.map((t, idx) => {
const ts = t.replace(regx, '').split(',');
- return {
+ const item = {
xL: parseFloat(ts[0]),
xU: parseFloat(ts[1]),
area: parseFloat(ts[2]),
absoluteArea: parseFloat(ts[3]),
};
+ const groupId = groupsByIdx[idx];
+ return groupId
+ ? Object.assign({}, item, { visualSplitGroupId: groupId })
+ : item;
});
stack = [...stack, ...itStack];
}
@@ -787,7 +809,7 @@ const ExtractJcamp = (source) => {
source,
{
xy: true,
- keepRecordsRegExp: /(\$CSTHRESHOLD|\$CSSCANAUTOTARGET|\$CSSCANEDITTARGET|\$CSSCANCOUNT|\$CSSOLVENTNAME|\$CSSOLVENTVALUE|\$CSSOLVENTX|\$CSCATEGORY|\$CSITAREA|\$CSITFACTOR|\$OBSERVEDINTEGRALS|\$OBSERVEDMULTIPLETS|\$OBSERVEDMULTIPLETSPEAKS|\.SOLVENTNAME|\.OBSERVEFREQUENCY|\$CSSIMULATIONPEAKS|\$CSUPPERTHRESHOLD|\$CSLOWERTHRESHOLD|\$CSCYCLICVOLTAMMETRYDATA|UNITS|SYMBOL|\$CSAUTOMETADATA|\$DETECTOR|MN|MW|D|MP|MELTINGPOINT|TG|\$CSSCANRATE|\$CSSPECTRUMDIRECTION|\$CSWEAREAVALUE|\$CSWEAREAUNIT|\$CSCURRENTMODE)/, // eslint-disable-line
+ keepRecordsRegExp: /(\$CSTHRESHOLD|\$CSSCANAUTOTARGET|\$CSSCANEDITTARGET|\$CSSCANCOUNT|\$CSSOLVENTNAME|\$CSSOLVENTVALUE|\$CSSOLVENTX|\$CSCATEGORY|\$CSITAREA|\$CSITFACTOR|\$OBSERVEDINTEGRALS|\$OBSERVEDINTEGRALSGROUPS|\$OBSERVEDMULTIPLETS|\$OBSERVEDMULTIPLETSPEAKS|\.SOLVENTNAME|\.OBSERVEFREQUENCY|\$CSSIMULATIONPEAKS|\$CSUPPERTHRESHOLD|\$CSLOWERTHRESHOLD|\$CSCYCLICVOLTAMMETRYDATA|UNITS|SYMBOL|\$CSAUTOMETADATA|\$DETECTOR|MN|MW|D|MP|MELTINGPOINT|TG|\$CSSCANRATE|\$CSSPECTRUMDIRECTION|\$CSWEAREAVALUE|\$CSWEAREAUNIT|\$CSCURRENTMODE)/, // eslint-disable-line
},
);
const layout = readLayout(jcamp);
@@ -886,4 +908,5 @@ export {
GetCyclicVoltaRatio, GetCyclicVoltaPeakSeparate,
Feature2MaxMinPeak, convertTopic, Convert2MaxMinPeak,
GetCyclicVoltaShiftOffset, GetCyclicVoltaPreviousShift,
+ buildIntegFeature,
};
diff --git a/src/helpers/compass.js b/src/helpers/compass.js
index 038faaff..2a4c76d6 100644
--- a/src/helpers/compass.js
+++ b/src/helpers/compass.js
@@ -1,5 +1,17 @@
import Format from './format';
import { Convert2DValue } from './chem';
+import { buildSweepPayloadFromXBounds } from './sweep.js'; // eslint-disable-line import/extensions
+import {
+ forgetPendingIntegrationDraft,
+ setPendingIntegrationDraft,
+} from './integration_draft.js'; // eslint-disable-line import/extensions
+import {
+ clearIntegrationSplitPreview,
+ drawIntegrationSplitPreview,
+ getIntegrationSplitTargetFromEvent,
+ getVisualSplitLineAtX,
+ isAlreadyVisuallySplit,
+} from './integration_split';
const d3 = require('d3');
@@ -10,26 +22,17 @@ const TfRescale = (focus) => {
};
const fetchPt = (event, focus, xt) => {
- // const rawMouseX = focus.isFirefox // WORKAROUND d3.mouse firefox compatibility
- // ? d3.event.offsetX
- // : d3.mouse(focus.root.node())[0];
const rawMouseX = d3.pointer(event, focus.root.node())[0];
const mouseX = xt.invert(rawMouseX);
const bisectDate = d3.bisector((d) => +d.x).left;
const dt = focus.data;
const ls = dt.length;
- const sortData = ls > 0 && dt[0].x > dt[ls - 1].x ? dt.reverse() : dt;
+ const sortData = ls > 0 && dt[0].x > dt[ls - 1].x ? [...dt].reverse() : dt;
const idx = bisectDate(sortData, +mouseX);
- return sortData[idx];
+ return sortData[Math.min(idx, ls - 1)];
};
const fetchFreePt = (event, focus, xt, yt) => {
- // const rawMouseX = focus.isFirefox // WORKAROUND d3.mouse firefox compatibility
- // ? d3.event.offsetX
- // : d3.mouse(focus.root.node())[0];
- // const rawMouseY = focus.isFirefox // WORKAROUND d3.mouse firefox compatibility
- // ? d3.event.offsetY
- // : d3.mouse(focus.root.node())[1];
const rawMouseX = d3.pointer(event, focus.root.node())[0];
const rawMouseY = d3.pointer(event, focus.root.node())[1];
const mouseX = xt.invert(rawMouseX);
@@ -55,6 +58,73 @@ const fetchFreePt = (event, focus, xt, yt) => {
return selectPoint;
};
+const clearIntegrationPreview = (focus) => {
+ if (!focus || !focus.root) return;
+ focus.root.select('.integration-preview-line').remove();
+};
+
+const drawIntegrationPreview = (focus, firstPoint, nextPoint) => {
+ if (!firstPoint || !nextPoint) return;
+ const { xt, yt } = TfRescale(focus);
+ const preview = focus.root.select('.integration-preview');
+ const line = preview.selectAll('.integration-preview-line').data([{
+ firstPoint,
+ nextPoint,
+ }]);
+
+ line.enter()
+ .append('line')
+ .attr('class', 'integration-preview-line')
+ .attr('stroke', 'red')
+ .attr('stroke-width', 2)
+ .attr('stroke-dasharray', '4,3')
+ .style('pointer-events', 'none')
+ .merge(line)
+ .attr('x1', (d) => xt(d.firstPoint.x))
+ .attr('y1', (d) => yt(d.firstPoint.y))
+ .attr('x2', (d) => xt(d.nextPoint.x))
+ .attr('y2', (d) => yt(d.nextPoint.y));
+};
+
+const getCurvePointFromEvent = (event, focus) => {
+ const { xt, yt } = TfRescale(focus);
+ if (Format.isCyclicVoltaLayout(focus.layout)) {
+ return fetchFreePt(event, focus, xt, yt);
+ }
+ return fetchPt(event, focus, xt);
+};
+
+const cancelIntegrationDraft = (focus) => {
+ Object.assign(focus, { firstIntegrationPoint: null });
+ clearIntegrationPreview(focus);
+ forgetPendingIntegrationDraft();
+};
+
+const updateIntegrationPreview = (event, focus) => {
+ if (!focus.isUiAddIntgSt || !focus.firstIntegrationPoint) return;
+ const pt = getCurvePointFromEvent(event, focus);
+ if (!pt) return;
+ drawIntegrationPreview(focus, focus.firstIntegrationPoint, pt);
+};
+
+const updateIntegrationSplitPreview = (event, focus) => {
+ if (!focus.isUiSplitIntgSt && !focus.isUiVisualSplitIntgSt) return;
+
+ const { splitX, target } = getIntegrationSplitTargetFromEvent(event, focus);
+ if (!target) {
+ clearIntegrationSplitPreview(focus);
+ return;
+ }
+
+ if (focus.isUiVisualSplitIntgSt && isAlreadyVisuallySplit(target)) {
+ clearIntegrationSplitPreview(focus);
+ return;
+ }
+
+ const { shift = 0, ignoreRef = false } = focus.integrationSplitTargets || {};
+ drawIntegrationSplitPreview(focus, target, splitX, shift, ignoreRef);
+};
+
const MouseMove = (event, focus) => {
const { xt, yt } = TfRescale(focus);
const { freq, layout, wavelength } = focus;
@@ -117,11 +187,92 @@ const MouseMove = (event, focus) => {
}
}
}
+ updateIntegrationPreview(event, focus);
+ updateIntegrationSplitPreview(event, focus);
+};
+
+const clickIntegrationPoint = (event, focus) => {
+ const pt = getCurvePointFromEvent(event, focus);
+ if (!pt) return;
+
+ const { firstIntegrationPoint, selectUiSweepAct } = focus;
+ if (!firstIntegrationPoint) {
+ // Keep the draft local to D3; the second click emits the existing sweep payload.
+ const draftPoint = {
+ x: pt.x,
+ y: pt.y,
+ jcampIdx: focus.jcampIdx,
+ dataLength: focus.data.length,
+ };
+ Object.assign(focus, { firstIntegrationPoint: draftPoint });
+ setPendingIntegrationDraft({
+ jcampIdx: focus.jcampIdx,
+ dataLength: focus.data.length,
+ cancel: () => cancelIntegrationDraft(focus),
+ });
+ drawIntegrationPreview(focus, draftPoint, draftPoint);
+ return;
+ }
+
+ cancelIntegrationDraft(focus);
+ if (firstIntegrationPoint.x === pt.x) {
+ return;
+ }
+
+ selectUiSweepAct(buildSweepPayloadFromXBounds(
+ focus,
+ firstIntegrationPoint.x,
+ pt.x,
+ ));
};
const ClickCompass = (event, focus) => {
event.stopPropagation();
event.preventDefault();
+ if (focus.isUiAddIntgSt) {
+ clickIntegrationPoint(event, focus);
+ return;
+ }
+ if (focus.isUiSplitIntgSt) {
+ const { splitX, target } = getIntegrationSplitTargetFromEvent(event, focus);
+ if (!target) return;
+
+ clearIntegrationSplitPreview(focus);
+ focus.splitIntegrationAct({
+ curveIdx: focus.jcampIdx,
+ target,
+ splitX,
+ data: focus.data,
+ });
+ return;
+ }
+ if (focus.isUiVisualSplitIntgSt) {
+ const { splitX, target } = getIntegrationSplitTargetFromEvent(event, focus);
+ if (!target) return;
+
+ const { stack = [], shift = 0 } = focus.integrationSplitTargets || {};
+ const existingSplitX = getVisualSplitLineAtX(focus, stack, splitX, shift);
+ clearIntegrationSplitPreview(focus);
+ if (Number.isFinite(existingSplitX)) {
+ if (typeof focus.removeVisualSplitLineAct !== 'function') return;
+ focus.removeVisualSplitLineAct({
+ curveIdx: focus.jcampIdx,
+ splitX: existingSplitX,
+ data: focus.data,
+ });
+ return;
+ }
+ if (isAlreadyVisuallySplit(target)) return;
+ if (typeof focus.addVisualSplitLineAct !== 'function') return;
+ focus.addVisualSplitLineAct({
+ curveIdx: focus.jcampIdx,
+ target,
+ splitX,
+ data: focus.data,
+ });
+ return;
+ }
+
const { xt, yt } = TfRescale(focus);
let pt = fetchPt(event, focus, xt);
const { layout, cyclicvoltaSt, jcampIdx } = focus;
@@ -147,6 +298,9 @@ const MountCompass = (focus) => {
.attr('class', 'compass');
const cursor = root.append('g')
.attr('class', 'cursor');
+ const preview = root.append('g')
+ .attr('class', 'integration-preview')
+ .attr('clip-path', 'url(#clip)');
const overlay = root.append('rect')
.attr('class', 'overlay-focus')
.attr('width', w)
@@ -174,6 +328,8 @@ const MountCompass = (focus) => {
.style('text-anchor', 'middle')
.style('fill', '#D68910');
+ preview.selectAll('*').remove();
+
overlay
.on('mousemove', (event) => MouseMove(event, focus))
.on('click', (event) => ClickCompass(event, focus));
@@ -184,4 +340,6 @@ export {
TfRescale,
ClickCompass,
MouseMove,
+ getCurvePointFromEvent,
+ clearIntegrationPreview,
};
diff --git a/src/helpers/integration.js b/src/helpers/integration.js
index 8fbfc1ab..865066e0 100644
--- a/src/helpers/integration.js
+++ b/src/helpers/integration.js
@@ -14,23 +14,35 @@ const getArea = (xL, xU, data) => {
return Math.abs(data[iU].k - data[iL].k);
};
+const getIntegrationPoints = (xL, xU, data) => data.filter((d) => (
+ d
+ && Number.isFinite(d.x)
+ && Number.isFinite(d.y)
+ && d.x > xL
+ && d.x < xU
+));
+
+const getLinearBaseline = (points) => {
+ if (!points || !points[0]) return () => 0;
+
+ const point1 = points[0];
+ const point2 = points[points.length - 1];
+ const slope = calcSlope(point1.x, point1.y, point2.x, point2.y);
+
+ return (point) => point1.y + slope * (point.x - point1.x);
+};
+
const getAbsoluteArea = (xL, xU, data) => {
- const ps = data.filter((d) => d.x > xL && d.x < xU);
- if (!ps[0]) return 0;
+ const ps = getIntegrationPoints(xL, xU, data);
+ if (ps.length < 2) return 0;
+ const baselineY = getLinearBaseline(ps);
let area = 0;
- const point1 = ps[0];
- const point2 = ps[ps.length - 1];
- const slope = 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);
+ const delta = Math.abs(pt.y - baselineY(pt));
area += delta;
}
}
@@ -38,6 +50,57 @@ const getAbsoluteArea = (xL, xU, data) => {
return area;
};
+const normalizeSplitLines = (splitLines) => {
+ if (!Array.isArray(splitLines)) return [];
+ const finiteValues = splitLines
+ .map((value) => parseFloat(value))
+ .filter((value) => Number.isFinite(value));
+ return [...new Set(finiteValues)].sort((a, b) => a - b);
+};
+
+const buildSplitIntervals = (xL, xU, splitLines = []) => {
+ if (!Number.isFinite(xL) || !Number.isFinite(xU)) return [];
+
+ const [lower, upper] = [xL, xU].sort((a, b) => a - b);
+ if (lower === upper) return [];
+
+ const sortedSplitLines = normalizeSplitLines(splitLines)
+ .filter((splitX) => splitX > lower && splitX < upper);
+
+ return [lower, ...sortedSplitLines, upper].slice(1).map((right, index, bounds) => ({
+ xL: index === 0 ? lower : bounds[index - 1],
+ xU: right,
+ }));
+};
+
+const getAbsoluteAreaWithBaseline = (xL, xU, data, baselineY) => {
+ const ps = getIntegrationPoints(xL, xU, data);
+ if (ps.length < 2 || typeof baselineY !== 'function') return 0;
+
+ let area = 0;
+ for (let i = 1; i < ps.length; i += 1) {
+ const pt = ps[i];
+ const baselineValue = baselineY(pt);
+ if (Number.isFinite(baselineValue)) {
+ area += Math.abs(pt.y - baselineValue);
+ }
+ }
+ return area;
+};
+
+const getSplitAreas = (xL, xU, splitLines, data) => {
+ const intervals = buildSplitIntervals(xL, xU, splitLines);
+ const mainPoints = getIntegrationPoints(xL, xU, data);
+ const baselineY = getLinearBaseline(mainPoints);
+
+ return intervals.map((interval) => ({
+ xL: interval.xL,
+ xU: interval.xU,
+ area: getArea(interval.xL, interval.xU, data),
+ absoluteArea: getAbsoluteAreaWithBaseline(interval.xL, interval.xU, data, baselineY),
+ }));
+};
+
const calcArea = (d, refArea, refFactor, ignoreRef = false) => {
if (ignoreRef) {
const { absoluteArea } = d;
@@ -46,4 +109,84 @@ const calcArea = (d, refArea, refFactor, ignoreRef = false) => {
return (d.area * refFactor / refArea).toFixed(2);
};
-export { getArea, calcArea, getAbsoluteArea }; // eslint-disable-line
+const splitAreaProportionally = (totalArea, leftRaw, rightRaw) => {
+ const safeTotal = Number.isFinite(totalArea) ? totalArea : 0;
+ if (safeTotal === 0) return { left: 0, right: 0 };
+
+ const safeLeft = Number.isFinite(leftRaw) ? Math.max(leftRaw, 0) : 0;
+ const safeRight = Number.isFinite(rightRaw) ? Math.max(rightRaw, 0) : 0;
+ const rawSum = safeLeft + safeRight;
+ if (rawSum <= 0) {
+ const half = safeTotal / 2;
+ return { left: half, right: half };
+ }
+
+ const ratio = safeTotal / rawSum;
+ return { left: safeLeft * ratio, right: safeRight * ratio };
+};
+
+let visualSplitGroupCounter = 0;
+const generateVisualSplitGroupId = () => {
+ visualSplitGroupCounter += 1;
+ const seed = (typeof Date !== 'undefined' && Date.now)
+ ? Date.now().toString(36)
+ : Math.random().toString(36).slice(2);
+ return `vsg-${seed}-${visualSplitGroupCounter}`;
+};
+
+const getVisualSplitGroups = (stack = []) => {
+ if (!Array.isArray(stack) || stack.length === 0) return [];
+ const groups = [];
+ let current = null;
+ stack.forEach((item) => {
+ const groupId = item && item.visualSplitGroupId;
+ if (groupId && current && current.groupId === groupId) {
+ current.items.push(item);
+ current.xL = Math.min(current.xL, item.xL);
+ current.xU = Math.max(current.xU, item.xU);
+ } else {
+ current = {
+ groupId: groupId || null,
+ items: [item],
+ xL: item.xL,
+ xU: item.xU,
+ isMerged: false,
+ };
+ groups.push(current);
+ }
+ });
+ groups.forEach((group) => {
+ // eslint-disable-next-line no-param-reassign
+ group.isMerged = !!group.groupId && group.items.length > 1;
+ });
+ return groups;
+};
+
+const getVisualSplitGroupBoundaries = (group) => {
+ if (!group || !group.isMerged) return [];
+ const sortedItems = [...group.items].sort((a, b) => a.xL - b.xL);
+ const boundaries = [];
+ for (let i = 0; i < sortedItems.length - 1; i += 1) {
+ const current = sortedItems[i];
+ const next = sortedItems[i + 1];
+ const boundary = (current.xU + next.xL) / 2;
+ if (Number.isFinite(boundary)) boundaries.push(boundary);
+ }
+ return boundaries;
+};
+
+export {
+ buildSplitIntervals,
+ calcArea,
+ generateVisualSplitGroupId,
+ getAbsoluteArea,
+ getAbsoluteAreaWithBaseline,
+ getArea,
+ getIntegrationPoints,
+ getLinearBaseline,
+ getSplitAreas,
+ getVisualSplitGroupBoundaries,
+ getVisualSplitGroups,
+ normalizeSplitLines,
+ splitAreaProportionally,
+}; // eslint-disable-line
diff --git a/src/helpers/integration_draft.js b/src/helpers/integration_draft.js
new file mode 100644
index 00000000..b911c1e9
--- /dev/null
+++ b/src/helpers/integration_draft.js
@@ -0,0 +1,45 @@
+let pendingIntegrationDraft = null;
+
+const cancelMessage = 'You are currently creating an integration. Are you sure you want to cancel it?';
+
+const hasPendingIntegrationDraft = () => !!pendingIntegrationDraft;
+
+const setPendingIntegrationDraft = (draft) => {
+ pendingIntegrationDraft = draft;
+};
+
+const forgetPendingIntegrationDraft = () => {
+ pendingIntegrationDraft = null;
+};
+
+const clearPendingIntegrationDraft = () => {
+ const draft = pendingIntegrationDraft;
+ pendingIntegrationDraft = null;
+ if (draft && typeof draft.cancel === 'function') {
+ draft.cancel();
+ }
+};
+
+const confirmCancelPendingIntegration = () => {
+ if (!hasPendingIntegrationDraft()) return true;
+
+ const shouldCancel = typeof window === 'undefined'
+ || typeof window.confirm !== 'function'
+ // This confirmation intentionally protects an in-progress two-click integration.
+ // eslint-disable-next-line no-alert
+ || window.confirm(cancelMessage);
+
+ if (shouldCancel) {
+ clearPendingIntegrationDraft();
+ }
+
+ return shouldCancel;
+};
+
+export {
+ clearPendingIntegrationDraft,
+ confirmCancelPendingIntegration,
+ forgetPendingIntegrationDraft,
+ hasPendingIntegrationDraft,
+ setPendingIntegrationDraft,
+};
diff --git a/src/helpers/integration_split.js b/src/helpers/integration_split.js
new file mode 100644
index 00000000..4331c577
--- /dev/null
+++ b/src/helpers/integration_split.js
@@ -0,0 +1,242 @@
+import {
+ getIntegrationPoints,
+ getLinearBaseline,
+ getVisualSplitGroupBoundaries,
+ getVisualSplitGroups,
+} from './integration';
+
+const d3 = require('d3');
+
+const SPLIT_PREVIEW_CLASS = 'integration-split-preview-line';
+const VISUAL_SPLIT_CLASS = 'integration-visual-split-line';
+const VISUAL_SPLIT_HIT_TOLERANCE_PX = 6;
+const NMR_SPLIT_PREVIEW_EXTENT = { y1: 38, y2: 55 };
+
+const getIntegrationBounds = (target, shift = 0) => (
+ [target.xL - shift, target.xU - shift].sort((a, b) => a - b)
+);
+
+const getSplitXFromEvent = (event, focus) => {
+ const rawMouseX = d3.pointer(event, focus.root.node())[0];
+ return focus.scales.x.invert(rawMouseX);
+};
+
+const clearIntegrationSplitPreview = (focus) => {
+ if (!focus || !focus.root) return;
+ focus.root.select(`.${SPLIT_PREVIEW_CLASS}`).remove();
+};
+
+const isAlreadyVisuallySplit = (target) => {
+ if (!target) return false;
+ return !!target.visualSplitGroupId || target.isMerged === true;
+};
+
+const isMergedVisualSplitGroup = (target) => !!(target && target.isMerged === true);
+
+const resolveBaselineContextBounds = (focus, target, shift) => {
+ if (target && target.isMerged === true) {
+ return getIntegrationBounds(target, shift);
+ }
+ const groupId = target && target.visualSplitGroupId;
+ const stack = focus && focus.integrationSplitTargets && focus.integrationSplitTargets.stack;
+ if (groupId && Array.isArray(stack)) {
+ const siblings = stack.filter((item) => item && item.visualSplitGroupId === groupId);
+ if (siblings.length > 1) {
+ const lower = Math.min(...siblings.map((item) => item.xL)) - shift;
+ const upper = Math.max(...siblings.map((item) => item.xU)) - shift;
+ return [lower, upper].sort((a, b) => a - b);
+ }
+ }
+ return getIntegrationBounds(target, shift);
+};
+
+const getIntegrationSplitTarget = (focus, splitX) => {
+ const splitTargets = focus && focus.integrationSplitTargets;
+ if (!splitTargets || !Number.isFinite(splitX)) return null;
+
+ const { stack = [], shift = 0 } = splitTargets;
+ return stack.find((target) => {
+ const [xL, xU] = getIntegrationBounds(target, shift);
+ return splitX > xL && splitX < xU;
+ });
+};
+
+const getIntegrationSplitTargetFromEvent = (event, focus) => {
+ const splitX = getSplitXFromEvent(event, focus);
+ const target = getIntegrationSplitTarget(focus, splitX);
+
+ return { splitX, target };
+};
+
+const getVisualSplitLines = (stack = [], shift = 0) => {
+ if (!Array.isArray(stack)) return [];
+ return getVisualSplitGroups(stack)
+ .filter((group) => group.isMerged)
+ .reduce((acc, group) => {
+ getVisualSplitGroupBoundaries(group).forEach((boundary) => {
+ const value = boundary - shift;
+ if (Number.isFinite(value)) acc.push(value);
+ });
+ return acc;
+ }, []);
+};
+
+const getVisualSplitLineAtX = (
+ focus,
+ stack,
+ splitX,
+ shift = 0,
+ pixelTolerance = VISUAL_SPLIT_HIT_TOLERANCE_PX,
+) => {
+ if (!focus || !focus.scales || !focus.scales.x || !Number.isFinite(splitX)) return null;
+
+ const xt = focus.scales.x;
+ const splitXPx = xt(splitX);
+ const nearest = getVisualSplitLines(stack, shift).reduce((acc, lineX) => {
+ const distance = Math.abs(xt(lineX) - splitXPx);
+ if (!acc || distance < acc.distance) {
+ return { splitX: lineX, distance };
+ }
+ return acc;
+ }, null);
+
+ return nearest && nearest.distance <= pixelTolerance ? nearest.splitX : null;
+};
+
+const interpolateY = (points, x) => {
+ if (!points || points.length === 0) return null;
+ const sortedPoints = [...points].sort((a, b) => a.x - b.x);
+ const upperIndex = sortedPoints.findIndex((point) => point.x >= x);
+ if (upperIndex < 0) return sortedPoints[sortedPoints.length - 1].y;
+ if (upperIndex === 0) return sortedPoints[0].y;
+
+ const lowerPoint = sortedPoints[upperIndex - 1];
+ const upperPoint = sortedPoints[upperIndex];
+ const xDelta = upperPoint.x - lowerPoint.x;
+ if (xDelta === 0) return lowerPoint.y;
+
+ const ratio = (x - lowerPoint.x) / xDelta;
+ return lowerPoint.y + ratio * (upperPoint.y - lowerPoint.y);
+};
+
+const resolveSplitPreviewExtent = (focus, target, splitX, shift, ignoreRef) => {
+ if (!focus || !target || !focus.scales || !focus.scales.y) return null;
+
+ const yt = focus.scales.y;
+ const [xL, xU] = getIntegrationBounds(target, shift);
+ if (!Number.isFinite(splitX) || splitX <= xL || splitX >= xU) return null;
+
+ if (!ignoreRef) {
+ return NMR_SPLIT_PREVIEW_EXTENT;
+ }
+
+ const [contextXL, contextXU] = resolveBaselineContextBounds(focus, target, shift);
+ const points = getIntegrationPoints(contextXL, contextXU, focus.data);
+ if (points.length < 2) return null;
+
+ const baselineY = getLinearBaseline(points);
+ const curveY = interpolateY(points, splitX);
+ const baseY = baselineY({ x: splitX });
+ if (!Number.isFinite(curveY) || !Number.isFinite(baseY)) return null;
+
+ return {
+ y1: yt(baseY),
+ y2: yt(curveY),
+ };
+};
+
+const drawIntegrationSplitPreview = (focus, target, splitX, shift, ignoreRef) => {
+ const extent = resolveSplitPreviewExtent(focus, target, splitX, shift, ignoreRef);
+ if (!extent) {
+ clearIntegrationSplitPreview(focus);
+ return;
+ }
+
+ const xt = focus.scales.x;
+ const x = xt(splitX);
+ const preview = focus.root.select('.integration-preview');
+ preview.raise();
+ const line = preview.selectAll(`.${SPLIT_PREVIEW_CLASS}`).data([extent]);
+
+ line.enter()
+ .append('line')
+ .attr('class', SPLIT_PREVIEW_CLASS)
+ .attr('stroke', 'red')
+ .attr('stroke-width', 2)
+ .attr('stroke-dasharray', '4,3')
+ .style('pointer-events', 'none')
+ .merge(line)
+ .attr('x1', x)
+ .attr('x2', x)
+ .attr('y1', (d) => d.y1)
+ .attr('y2', (d) => d.y2);
+};
+
+const drawIntegrationVisualSplitLines = (
+ focus,
+ stack = [],
+ shift = 0,
+ ignoreRef = false,
+ isInteractive = false,
+ onClickLine = null,
+) => {
+ if (!focus || !focus.tags || !focus.tags.visualSplitPath) return;
+
+ const groups = getVisualSplitGroups(stack).filter((group) => group.isMerged);
+ const splitLines = groups.reduce((acc, group) => {
+ const groupTarget = { xL: group.xL, xU: group.xU };
+ getVisualSplitGroupBoundaries(group).forEach((boundary) => {
+ const splitX = boundary - shift;
+ const extent = resolveSplitPreviewExtent(focus, groupTarget, splitX, shift, ignoreRef);
+ if (extent) {
+ acc.push({
+ splitX,
+ key: `${group.groupId || `${group.xL}-${group.xU}`}-${splitX}`,
+ ...extent,
+ });
+ }
+ });
+ return acc;
+ }, []);
+
+ const xt = focus.scales.x;
+ const lines = focus.tags.visualSplitPath
+ .selectAll(`line.${VISUAL_SPLIT_CLASS}`)
+ .data(splitLines, (d) => d.key);
+
+ lines.exit()
+ .attr('class', 'exit')
+ .remove();
+
+ lines.enter()
+ .append('line')
+ .attr('class', VISUAL_SPLIT_CLASS)
+ .attr('stroke', 'red')
+ .attr('stroke-width', 2)
+ .merge(lines)
+ .attr('x1', (d) => xt(d.splitX))
+ .attr('x2', (d) => xt(d.splitX))
+ .attr('y1', (d) => d.y1)
+ .attr('y2', (d) => d.y2)
+ .style('pointer-events', isInteractive ? 'stroke' : 'none')
+ .on('click', isInteractive && onClickLine
+ ? (event, d) => onClickLine(event, d.splitX)
+ : null);
+};
+
+export {
+ NMR_SPLIT_PREVIEW_EXTENT,
+ clearIntegrationSplitPreview,
+ drawIntegrationSplitPreview,
+ drawIntegrationVisualSplitLines,
+ getIntegrationBounds,
+ getIntegrationSplitTarget,
+ getIntegrationSplitTargetFromEvent,
+ getSplitXFromEvent,
+ getVisualSplitLineAtX,
+ getVisualSplitLines,
+ interpolateY,
+ isAlreadyVisuallySplit,
+ isMergedVisualSplitGroup,
+ resolveSplitPreviewExtent,
+};
diff --git a/src/helpers/mount.js b/src/helpers/mount.js
index d91d7a5f..2c4cf9a1 100644
--- a/src/helpers/mount.js
+++ b/src/helpers/mount.js
@@ -34,11 +34,14 @@ const MountTags = (target) => {
const aucPath = target.root.append('g')
.attr('class', 'aucPath-clip')
.attr('clip-path', 'url(#clip)');
+ const visualSplitPath = target.root.append('g')
+ .attr('class', 'integration-visual-splits')
+ .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
+ pPath, bpPath, bpTxt, igbPath, igcPath, igtPath, mpybPath, mpyt1Path, mpyt2Path, mpypPath, aucPath, visualSplitPath, peckerPath, // eslint-disable-line
};
};
diff --git a/src/helpers/sweep.js b/src/helpers/sweep.js
new file mode 100644
index 00000000..6a30b8bc
--- /dev/null
+++ b/src/helpers/sweep.js
@@ -0,0 +1,23 @@
+const resolveVisibleYExtent = (focus) => {
+ const { currentExtent, h, scales } = focus;
+ if (currentExtent && currentExtent.yExtent) {
+ return currentExtent.yExtent;
+ }
+
+ const yes = [h, 0].map(scales.y.invert).sort((a, b) => a - b);
+ return { yL: yes[0], yU: yes[1] };
+};
+
+const buildSweepPayloadFromXBounds = (focus, xA, xB) => {
+ const { data, dataPks } = focus;
+ const xes = [xA, xB].map((x) => Number(x)).sort((a, b) => a - b);
+
+ return {
+ xExtent: { xL: xes[0], xU: xes[1] },
+ yExtent: resolveVisibleYExtent(focus),
+ data,
+ dataPks,
+ };
+};
+
+export { buildSweepPayloadFromXBounds, resolveVisibleYExtent };
diff --git a/src/layer_prism.js b/src/layer_prism.js
index a81a4d26..0d13fc94 100644
--- a/src/layer_prism.js
+++ b/src/layer_prism.js
@@ -21,14 +21,21 @@ const styles = () => ({
const LayerPrism = ({
entity, cLabel, xLabel, yLabel, forecast, operations,
descriptions, molSvg, editorOnly, exactMass,
- thresSt, scanSt, uiSt,
+ thresSt, scanSt, uiSt, curveSt, integrationSt,
canChangeDescription, onDescriptionChanged,
}) => {
const {
- topic, feature, hasEdit, integration,
+ topic, feature, hasEdit, integration: initialIntegration,
} = extractParams(entity, thresSt, scanSt);
if (!topic) return null;
+ const curveIdx = (curveSt && Number.isFinite(curveSt.curveIdx)) ? curveSt.curveIdx : 0;
+ const liveIntegrations = (integrationSt && Array.isArray(integrationSt.integrations))
+ ? integrationSt.integrations
+ : null;
+ const liveIntegration = liveIntegrations ? liveIntegrations[curveIdx] : null;
+ const integration = liveIntegration || initialIntegration;
+
const { viewer } = uiSt;
if (viewer === LIST_UI_VIEWER_TYPE.ANALYSIS) {
return (
@@ -104,6 +111,8 @@ const mapStateToProps = (state, props) => ( // eslint-disable-line
scanSt: state.scan,
thresSt: state.threshold.list[state.curve.curveIdx],
uiSt: state.ui,
+ curveSt: state.curve,
+ integrationSt: state.integration.present,
}
);
@@ -126,6 +135,8 @@ LayerPrism.propTypes = {
thresSt: PropTypes.object.isRequired,
scanSt: PropTypes.object.isRequired,
uiSt: PropTypes.object.isRequired,
+ curveSt: PropTypes.object.isRequired,
+ integrationSt: PropTypes.object.isRequired,
canChangeDescription: PropTypes.bool.isRequired,
onDescriptionChanged: PropTypes.func,
};
diff --git a/src/reducers/reducer_integration.js b/src/reducers/reducer_integration.js
index 01352986..869a12d4 100644
--- a/src/reducers/reducer_integration.js
+++ b/src/reducers/reducer_integration.js
@@ -3,7 +3,12 @@ import undoable from 'redux-undo';
import {
UI, INTEGRATION, EDITPEAK, MANAGER,
} from '../constants/action_type';
-import { getArea, getAbsoluteArea } from '../helpers/integration';
+import {
+ generateVisualSplitGroupId,
+ getAbsoluteArea,
+ getArea,
+ splitAreaProportionally,
+} from '../helpers/integration';
import { undoRedoConfig, undoRedoActions } from './undo_redo_config';
const initialState = {
@@ -39,7 +44,7 @@ const addToStack = (state, action) => {
const { stack, refArea, shift } = selectedIntegration;
const { xExtent, data } = newData;
const { xL, xU } = xExtent;
- if (!xL || !xU || (xU - xL) === 0) { return state; }
+ if (!Number.isFinite(xL) || !Number.isFinite(xU) || (xU - xL) === 0) { return state; }
const area = getArea(xL, xU, data);
const defaultRefArea = stack.length === 0 ? area : refArea;
@@ -61,6 +66,20 @@ const addToStack = (state, action) => {
return Object.assign({}, state, { integrations: newArrIntegration, selectedIdx: curveIdx });
};
+const dropOrphanVisualSplitGroupIds = (stack) => {
+ const groupCounts = stack.reduce((acc, item) => {
+ const groupId = item && item.visualSplitGroupId;
+ if (groupId) acc[groupId] = (acc[groupId] || 0) + 1;
+ return acc;
+ }, {});
+ return stack.map((item) => {
+ const groupId = item && item.visualSplitGroupId;
+ if (!groupId || groupCounts[groupId] > 1) return item;
+ const { visualSplitGroupId, ...rest } = item;
+ return rest;
+ });
+};
+
const rmFromStack = (state, action) => {
const { dataToRemove, curveIdx } = action.payload;
const { xL, xU, xExtent } = dataToRemove;
@@ -71,14 +90,325 @@ const rmFromStack = (state, action) => {
const { stack } = selectedIntegration;
let [txL, txU] = [0, 0];
- if (xL && xU) { // rm click integration
+ if (Number.isFinite(xL) && Number.isFinite(xU)) {
[txL, txU] = [xL, xU];
- } else if (xExtent) { // rm click multiplicity
+ } else if (xExtent) {
[txL, txU] = [xExtent.xL, xExtent.xU];
} else {
return state;
}
- const newStack = stack.filter((k) => k.xL !== txL && k.xU !== txU);
+ const filteredStack = stack.filter((k) => k.xL !== txL && k.xU !== txU);
+ const newStack = dropOrphanVisualSplitGroupIds(filteredStack);
+
+ const newIntegration = Object.assign({}, selectedIntegration, { stack: newStack });
+ const newArrIntegration = [...integrations];
+ newArrIntegration[curveIdx] = newIntegration;
+
+ return Object.assign({}, state, { integrations: newArrIntegration, selectedIdx: curveIdx });
+};
+
+const hasEnoughDataResolution = (xL, xU, data) => {
+ const [lower, upper] = [xL, xU].sort((a, b) => a - b);
+ const points = data.filter((pt) => (
+ pt
+ && Number.isFinite(pt.x)
+ && pt.x >= lower
+ && pt.x <= upper
+ ));
+ if (points.length < 2) return false;
+
+ return points.some((pt) => pt.x !== points[0].x);
+};
+
+const computeProportionalSplitAreas = (xL, splitX, xU, data, original) => {
+ const areaParts = splitAreaProportionally(
+ original.area,
+ getArea(xL, splitX, data),
+ getArea(splitX, xU, data),
+ );
+ const absParts = splitAreaProportionally(
+ original.absoluteArea,
+ getAbsoluteArea(xL, splitX, data),
+ getAbsoluteArea(splitX, xU, data),
+ );
+ return {
+ leftArea: areaParts.left,
+ rightArea: areaParts.right,
+ leftAbs: absParts.left,
+ rightAbs: absParts.right,
+ };
+};
+
+const buildSplitStackItem = (xL, xU, shift, area, absoluteArea) => {
+ const [lower, upper] = [xL, xU].sort((a, b) => a - b);
+ return {
+ xL: lower + shift,
+ xU: upper + shift,
+ area,
+ absoluteArea,
+ };
+};
+
+const getVisualSplitTolerance = (xL, xU) => Math.max(Math.abs(xU - xL) * 1e-6, Number.EPSILON);
+
+const findTargetIntegrationIndex = (stack, target) => stack.findIndex((item) => (
+ item.xL === target.xL && item.xU === target.xU
+));
+
+const buildVisualSplitItem = (xL, xU, shift, area, absoluteArea, groupId) => {
+ const [lower, upper] = [xL, xU].sort((a, b) => a - b);
+ const item = {
+ xL: lower + shift,
+ xU: upper + shift,
+ area,
+ absoluteArea,
+ };
+ if (groupId) item.visualSplitGroupId = groupId;
+ return item;
+};
+
+const isVisuallySplit = (stack, item) => {
+ if (!item || !item.visualSplitGroupId) return false;
+ return stack.some((other) => (
+ other !== item && other.visualSplitGroupId === item.visualSplitGroupId
+ ));
+};
+
+const buildRawSplitPart = (xL, xU, shift, data) => buildSplitStackItem(
+ xL,
+ xU,
+ shift,
+ getArea(xL, xU, data),
+ getAbsoluteArea(xL, xU, data),
+);
+
+const findVisualSplitNeighborhood = (stack, original, shift, xL, xU) => {
+ const groupId = original && original.visualSplitGroupId;
+ if (!groupId) return { hasLeft: false, hasRight: false };
+
+ const tolerance = getVisualSplitTolerance(xL, xU);
+ const isGroupSibling = (item) => (
+ item !== original && item.visualSplitGroupId === groupId
+ );
+
+ return {
+ hasLeft: stack.some((item) => (
+ isGroupSibling(item) && Math.abs((item.xU - shift) - xL) <= tolerance
+ )),
+ hasRight: stack.some((item) => (
+ isGroupSibling(item) && Math.abs((item.xL - shift) - xU) <= tolerance
+ )),
+ };
+};
+
+const buildSplitParts = (original, xL, splitX, xU, shift, data, stack) => {
+ if (!original.visualSplitGroupId) {
+ return [
+ buildRawSplitPart(xL, splitX, shift, data),
+ buildRawSplitPart(splitX, xU, shift, data),
+ ];
+ }
+
+ const { hasLeft, hasRight } = findVisualSplitNeighborhood(stack, original, shift, xL, xU);
+ if (!hasLeft && !hasRight) {
+ return [
+ buildRawSplitPart(xL, splitX, shift, data),
+ buildRawSplitPart(splitX, xU, shift, data),
+ ];
+ }
+
+ const groupId = original.visualSplitGroupId;
+ const {
+ leftArea, rightArea, leftAbs, rightAbs,
+ } = computeProportionalSplitAreas(xL, splitX, xU, data, original);
+
+ const leftStaysInGroup = hasLeft;
+ const rightStaysInGroup = hasRight;
+
+ const leftPart = leftStaysInGroup
+ ? buildVisualSplitItem(xL, splitX, shift, leftArea, leftAbs, groupId)
+ : buildSplitStackItem(xL, splitX, shift, leftArea, leftAbs);
+ const rightPart = rightStaysInGroup
+ ? buildVisualSplitItem(splitX, xU, shift, rightArea, rightAbs, groupId)
+ : buildSplitStackItem(splitX, xU, shift, rightArea, rightAbs);
+
+ return [leftPart, rightPart];
+};
+
+const splitStack = (state, action) => {
+ const {
+ curveIdx, target, splitX, data,
+ } = action.payload;
+
+ if (!Number.isFinite(curveIdx) || !target || !Array.isArray(data)) {
+ return state;
+ }
+
+ const { integrations } = state;
+ const selectedIntegration = integrations[curveIdx];
+ if (!selectedIntegration || selectedIntegration === false) {
+ return state;
+ }
+
+ const { stack, shift } = selectedIntegration;
+ const targetIndex = findTargetIntegrationIndex(stack, target);
+ if (targetIndex < 0 || !Number.isFinite(splitX)) {
+ return state;
+ }
+
+ const original = stack[targetIndex];
+ const [xL, xU] = [original.xL - shift, original.xU - shift].sort((a, b) => a - b);
+ if (!Number.isFinite(xL) || !Number.isFinite(xU) || splitX <= xL || splitX >= xU) {
+ return state;
+ }
+
+ if (!hasEnoughDataResolution(xL, splitX, data) || !hasEnoughDataResolution(splitX, xU, data)) {
+ return state;
+ }
+
+ const [leftIntegration, rightIntegration] = buildSplitParts(
+ original, xL, splitX, xU, shift, data, stack,
+ );
+
+ const newStack = dropOrphanVisualSplitGroupIds([
+ ...stack.slice(0, targetIndex),
+ leftIntegration,
+ rightIntegration,
+ ...stack.slice(targetIndex + 1),
+ ]);
+
+ const newIntegration = Object.assign({}, selectedIntegration, { stack: newStack });
+ const newArrIntegration = [...integrations];
+ newArrIntegration[curveIdx] = newIntegration;
+
+ return Object.assign({}, state, { integrations: newArrIntegration, selectedIdx: curveIdx });
+};
+
+const addVisualSplitLine = (state, action) => {
+ const {
+ curveIdx, target, splitX, data,
+ } = action.payload;
+
+ if (!Number.isFinite(curveIdx) || !target || !Number.isFinite(splitX) || !Array.isArray(data)) {
+ return state;
+ }
+
+ const { integrations } = state;
+ const selectedIntegration = integrations[curveIdx];
+ if (!selectedIntegration || selectedIntegration === false) {
+ return state;
+ }
+
+ const { stack, shift } = selectedIntegration;
+ const targetIndex = findTargetIntegrationIndex(stack, target);
+ if (targetIndex < 0) return state;
+
+ const original = stack[targetIndex];
+
+ if (original.visualSplitGroupId || isVisuallySplit(stack, original)) {
+ return state;
+ }
+
+ const [xL, xU] = [original.xL - shift, original.xU - shift].sort((a, b) => a - b);
+ const tolerance = getVisualSplitTolerance(xL, xU);
+ if (splitX <= xL + tolerance || splitX >= xU - tolerance) {
+ return state;
+ }
+ if (!hasEnoughDataResolution(xL, splitX, data) || !hasEnoughDataResolution(splitX, xU, data)) {
+ return state;
+ }
+
+ const groupId = generateVisualSplitGroupId();
+ const {
+ leftArea, rightArea, leftAbs, rightAbs,
+ } = computeProportionalSplitAreas(xL, splitX, xU, data, original);
+ const leftItem = buildVisualSplitItem(xL, splitX, shift, leftArea, leftAbs, groupId);
+ const rightItem = buildVisualSplitItem(splitX, xU, shift, rightArea, rightAbs, groupId);
+
+ if (leftItem.xL >= leftItem.xU
+ || rightItem.xL >= rightItem.xU
+ || leftItem.xU !== rightItem.xL) {
+ return state;
+ }
+
+ const newStack = [
+ ...stack.slice(0, targetIndex),
+ leftItem,
+ rightItem,
+ ...stack.slice(targetIndex + 1),
+ ];
+
+ const newIntegration = Object.assign({}, selectedIntegration, { stack: newStack });
+ const newArrIntegration = [...integrations];
+ newArrIntegration[curveIdx] = newIntegration;
+
+ return Object.assign({}, state, { integrations: newArrIntegration, selectedIdx: curveIdx });
+};
+
+const removeVisualSplitLine = (state, action) => {
+ const {
+ curveIdx, splitX, data,
+ } = action.payload;
+
+ if (!Number.isFinite(curveIdx) || !Number.isFinite(splitX) || !Array.isArray(data)) {
+ return state;
+ }
+
+ const { integrations } = state;
+ const selectedIntegration = integrations[curveIdx];
+ if (!selectedIntegration || selectedIntegration === false) {
+ return state;
+ }
+
+ const { stack, shift } = selectedIntegration;
+ if (!Array.isArray(stack) || stack.length < 2) return state;
+
+ const tolerance = getVisualSplitTolerance(
+ Math.min(...stack.map((s) => s.xL - shift)),
+ Math.max(...stack.map((s) => s.xU - shift)),
+ );
+
+ let mergeStartIdx = -1;
+ for (let i = 0; i < stack.length - 1; i += 1) {
+ const left = stack[i];
+ const right = stack[i + 1];
+ const gapTolerance = Math.max(tolerance, Math.abs(left.xU - right.xL));
+ if (
+ left.visualSplitGroupId
+ && left.visualSplitGroupId === right.visualSplitGroupId
+ && Math.abs((left.xU - shift) - splitX) <= gapTolerance
+ && Math.abs((right.xL - shift) - splitX) <= gapTolerance
+ ) {
+ mergeStartIdx = i;
+ break;
+ }
+ }
+ if (mergeStartIdx < 0) return state;
+
+ const leftItem = stack[mergeStartIdx];
+ const rightItem = stack[mergeStartIdx + 1];
+ const groupId = leftItem.visualSplitGroupId;
+ const mergedXL = Math.min(leftItem.xL, rightItem.xL) - shift;
+ const mergedXU = Math.max(leftItem.xU, rightItem.xU) - shift;
+
+ const remainingInGroup = stack.filter((item, idx) => (
+ idx !== mergeStartIdx && idx !== mergeStartIdx + 1 && item.visualSplitGroupId === groupId
+ ));
+ const keepGroupId = remainingInGroup.length > 0;
+ const mergedItem = buildVisualSplitItem(
+ mergedXL,
+ mergedXU,
+ shift,
+ (leftItem.area || 0) + (rightItem.area || 0),
+ (leftItem.absoluteArea || 0) + (rightItem.absoluteArea || 0),
+ keepGroupId ? groupId : null,
+ );
+
+ const newStack = [
+ ...stack.slice(0, mergeStartIdx),
+ mergedItem,
+ ...stack.slice(mergeStartIdx + 2),
+ ];
const newIntegration = Object.assign({}, selectedIntegration, { stack: newStack });
const newArrIntegration = [...integrations];
@@ -159,6 +489,12 @@ const integrationReducer = (state = initialState, action) => {
return addToStack(state, action);
case INTEGRATION.RM_ONE:
return rmFromStack(state, action);
+ case INTEGRATION.SPLIT:
+ return splitStack(state, action);
+ case INTEGRATION.ADD_VISUAL_SPLIT:
+ return addVisualSplitLine(state, action);
+ case INTEGRATION.RM_VISUAL_SPLIT:
+ return removeVisualSplitLine(state, action);
case INTEGRATION.SET_REF:
return setRef(state, action);
case INTEGRATION.SET_FKR:
@@ -183,4 +519,6 @@ const undoableIntegrationReducer = undoable(
undoRedoConfig,
);
+export { integrationReducer };
+
export default undoableIntegrationReducer;
diff --git a/src/reducers/undo_redo_config.js b/src/reducers/undo_redo_config.js
index 2c52e048..b24db61e 100644
--- a/src/reducers/undo_redo_config.js
+++ b/src/reducers/undo_redo_config.js
@@ -11,7 +11,8 @@ const undoRedoActions = [
MANAGER.RESET_INIT_MS, MANAGER.RESET_INIT_COMMON_WITH_INTERGATION,
UI.SWEEP.SELECT_INTEGRATION,
UI.SWEEP.SELECT_MULTIPLICITY_RDC,
- INTEGRATION.RM_ONE, INTEGRATION.SET_REF, INTEGRATION.SET_FKR,
+ INTEGRATION.RM_ONE, INTEGRATION.SET_REF, INTEGRATION.SET_FKR, INTEGRATION.SPLIT,
+ INTEGRATION.ADD_VISUAL_SPLIT, INTEGRATION.RM_VISUAL_SPLIT,
INTEGRATION.RESET_ALL, INTEGRATION.CLEAR_ALL,
MULTIPLICITY.PEAK_RM_BY_PANEL_RDC, MULTIPLICITY.PEAK_RM_BY_UI_RDC,
MULTIPLICITY.PEAK_ADD_BY_UI_RDC, MULTIPLICITY.RESET_ONE_RDC,
@@ -23,7 +24,7 @@ const undoRedoActions = [
const undoRedoConfig = {
debug: false,
limit: 10,
- ignoreInitialState: true,
+ ignoreInitialState: false,
filter: includeAction(undoRedoActions),
clearHistoryType: [
EDITPEAK.SHIFT, EDITPEAK.CLEAR_ALL,