@complat/react-spectra-editor 1.7.1 → 1.8.0

package/dist/reducers/reducer_hplc_ms/uvvis.js

@@ -0,0 +1,377 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.uvvisUndo = exports.uvvisRedo = exports.updateWavelength = exports.updateHplcMsPeaks = exports.updateHplcMsIntegrations = exports.removeHplcMsPeak = exports.recordUvvisEditBefore = exports.emptyUvvisHistory = exports.clearIntegrationAllHplcMs = exports.clearAllPeaksHplcMs = void 0;
+var _integration = require("../../helpers/integration");
+var _utils = require("./utils");
+var _persistence = require("./persistence");
+/* eslint-disable prefer-object-spread, default-param-last */
+
+const MAX_UVVIS_UNDO = 50;
+const emptyUvvisHistory = () => ({
+  past: [],
+  future: []
+});
+exports.emptyUvvisHistory = emptyUvvisHistory;
+const captureUvvisEditSnapshot = state => {
+  const {
+    uvvis
+  } = state;
+  const {
+    spectraList = [],
+    selectedWaveLength,
+    wavelengthIdx
+  } = uvvis;
+  return {
+    selectedWaveLength,
+    wavelengthIdx,
+    spectraList: spectraList.map(sp => ({
+      peaks: (sp.peaks || []).map(p => ({
+        ...p
+      })),
+      integrations: JSON.parse(JSON.stringify(sp.integrations || []))
+    }))
+  };
+};
+const restoreUvvisEditSnapshot = (state, snap) => {
+  const {
+    uvvis
+  } = state;
+  const newSpectraList = uvvis.spectraList.map((sp, i) => {
+    const p = snap.spectraList[i];
+    if (!p) return sp;
+    return {
+      ...sp,
+      peaks: (p.peaks || []).map(x => ({
+        ...x
+      })),
+      integrations: JSON.parse(JSON.stringify(p.integrations || []))
+    };
+  });
+  const wlIdx = Number.isInteger(snap.wavelengthIdx) ? snap.wavelengthIdx : 0;
+  const safeIdx = wlIdx >= 0 && wlIdx < newSpectraList.length ? wlIdx : 0;
+  const currentSpectrum = newSpectraList[safeIdx] || null;
+  return {
+    ...state,
+    uvvis: {
+      ...uvvis,
+      selectedWaveLength: snap.selectedWaveLength,
+      wavelengthIdx: safeIdx,
+      spectraList: newSpectraList,
+      currentSpectrum
+    }
+  };
+};
+const recordUvvisEditBefore = state => {
+  const hist = state.uvvisEditHistory || emptyUvvisHistory();
+  const snap = captureUvvisEditSnapshot(state);
+  const past = [...hist.past, snap].slice(-MAX_UVVIS_UNDO);
+  return {
+    ...state,
+    uvvisEditHistory: {
+      past,
+      future: []
+    }
+  };
+};
+exports.recordUvvisEditBefore = recordUvvisEditBefore;
+const uvvisUndo = state => {
+  const hist = state.uvvisEditHistory || emptyUvvisHistory();
+  if (!hist.past.length) return state;
+  const past = [...hist.past];
+  const prior = past.pop();
+  const currentSnap = captureUvvisEditSnapshot(state);
+  const future = [currentSnap, ...hist.future];
+  const restored = restoreUvvisEditSnapshot(state, prior);
+  return {
+    ...restored,
+    uvvisEditHistory: {
+      past,
+      future
+    }
+  };
+};
+exports.uvvisUndo = uvvisUndo;
+const uvvisRedo = state => {
+  const hist = state.uvvisEditHistory || emptyUvvisHistory();
+  if (!hist.future.length) return state;
+  const [next, ...restFuture] = hist.future;
+  const past = [...hist.past, captureUvvisEditSnapshot(state)].slice(-MAX_UVVIS_UNDO);
+  const restored = restoreUvvisEditSnapshot(state, next);
+  return {
+    ...restored,
+    uvvisEditHistory: {
+      past,
+      future: restFuture
+    }
+  };
+};
+exports.uvvisRedo = uvvisRedo;
+const updateHplcMsPeaks = (state, action) => {
+  const {
+    spectrumId,
+    peaks
+  } = action.payload || {};
+  const {
+    uvvis
+  } = state;
+  const {
+    spectraList = [],
+    listWaveLength = []
+  } = uvvis;
+  const normalizedSpectrumId = (0, _utils.normalizeSpectrumId)(spectrumId);
+  const spectrumIndex = listWaveLength.map(waveLength => (0, _utils.normalizeSpectrumId)(waveLength)).indexOf(normalizedSpectrumId);
+  if (spectrumIndex === -1) return state;
+  const st = action.meta?.skipUvvisHistory ? state : recordUvvisEditBefore(state);
+  const newSpectraList = [...spectraList];
+  const updatedSpectrum = {
+    ...newSpectraList[spectrumIndex],
+    peaks
+  };
+  newSpectraList[spectrumIndex] = updatedSpectrum;
+  const newCurrentSpectrum = (0, _utils.normalizeSpectrumId)(uvvis.selectedWaveLength) === normalizedSpectrumId ? updatedSpectrum : uvvis.currentSpectrum;
+  return {
+    ...st,
+    uvvis: {
+      ...uvvis,
+      spectraList: newSpectraList,
+      currentSpectrum: newCurrentSpectrum
+    }
+  };
+};
+exports.updateHplcMsPeaks = updateHplcMsPeaks;
+const updateWavelength = (state, action) => {
+  const {
+    payload
+  } = action;
+  if (payload?.target) {
+    const {
+      value
+    } = payload.target;
+    const {
+      uvvis
+    } = state;
+    const {
+      listWaveLength = [],
+      spectraList = []
+    } = uvvis;
+    const normalizedValue = (0, _utils.normalizeSpectrumId)(value);
+    const normalizedWaveLengths = listWaveLength.map(waveLength => (0, _utils.normalizeSpectrumId)(waveLength));
+    const wavelengthIdx = normalizedWaveLengths.indexOf(normalizedValue);
+    const currentSpectrum = spectraList.find((spectrum, index) => normalizedWaveLengths[index] === normalizedValue);
+    const next = {
+      ...state,
+      uvvis: {
+        ...uvvis,
+        selectedWaveLength: normalizedValue,
+        wavelengthIdx,
+        spectraList,
+        currentSpectrum
+      }
+    };
+    (0, _persistence.persistLcmsUvvisWavelength)(state.lcmsDatasetKey, normalizedValue);
+    return next;
+  }
+  return state;
+};
+exports.updateWavelength = updateWavelength;
+const updateHplcMsIntegrations = (state, action) => {
+  const {
+    spectrumId,
+    integration,
+    remove,
+    shift = 0
+  } = action.payload || {};
+  const {
+    uvvis
+  } = state;
+  const {
+    spectraList = [],
+    listWaveLength = []
+  } = uvvis;
+  const normalizedSpectrumId = (0, _utils.normalizeSpectrumId)(spectrumId);
+  const curveIdx = listWaveLength.map(waveLength => (0, _utils.normalizeSpectrumId)(waveLength)).indexOf(normalizedSpectrumId);
+  if (curveIdx === -1) {
+    return state;
+  }
+  const selectedSpectrum = spectraList[curveIdx];
+  if (!selectedSpectrum) {
+    return state;
+  }
+  const getRange = intg => {
+    const xL = intg?.xExtent?.xL ?? intg?.xL;
+    const xU = intg?.xExtent?.xU ?? intg?.xU;
+    return {
+      xL,
+      xU
+    };
+  };
+  if (remove) {
+    const {
+      xL: rmXL,
+      xU: rmXU
+    } = getRange(integration);
+    if (rmXL == null || rmXU == null) return state;
+    const stRm = action.meta?.skipUvvisHistory ? state : recordUvvisEditBefore(state);
+    const uvRm = stRm.uvvis;
+    const spListRm = uvRm.spectraList;
+    const specRm = spListRm[curveIdx];
+    const intRm = specRm.integrations || [];
+    const newIntegrations = intRm.filter(intg => {
+      const {
+        xL,
+        xU
+      } = getRange(intg);
+      if (xL == null || xU == null) return true;
+      return !(Math.abs(xL - rmXL) < 1e-6 && Math.abs(xU - rmXU) < 1e-6);
+    });
+    const newSpectrum = {
+      ...specRm,
+      integrations: newIntegrations
+    };
+    const newSpectraList = [...spListRm];
+    newSpectraList[curveIdx] = newSpectrum;
+    return {
+      ...stRm,
+      uvvis: {
+        ...uvRm,
+        spectraList: newSpectraList,
+        currentSpectrum: (0, _utils.normalizeSpectrumId)(uvRm.selectedWaveLength) === normalizedSpectrumId ? newSpectrum : uvRm.currentSpectrum
+      }
+    };
+  }
+  if (!integration) {
+    return state;
+  }
+  const {
+    xExtent,
+    data
+  } = integration;
+  if (!xExtent || !data || xExtent.xL == null || xExtent.xU == null || xExtent.xU === xExtent.xL) {
+    return state;
+  }
+  const stAdd = action.meta?.skipUvvisHistory ? state : recordUvvisEditBefore(state);
+  const uvAdd = stAdd.uvvis;
+  const spListAdd = uvAdd.spectraList;
+  const specAdd = spListAdd[curveIdx];
+  const integrationsAdd = specAdd.integrations || [];
+  const {
+    xL,
+    xU
+  } = xExtent;
+  const area = (0, _integration.getArea)(xL, xU, data);
+  const absoluteArea = (0, _integration.getAbsoluteArea)(xL, xU, data);
+  const isFirst = integrationsAdd.length === 0;
+  const newIntegration = {
+    xL: xL + shift,
+    xU: xU + shift,
+    area,
+    absoluteArea,
+    refArea: isFirst ? area : integrationsAdd[0]?.refArea ?? area,
+    xExtent,
+    data
+  };
+  const newIntegrations = [...integrationsAdd, newIntegration];
+  const newSpectrum = {
+    ...specAdd,
+    integrations: newIntegrations
+  };
+  const newSpectraList = [...spListAdd];
+  newSpectraList[curveIdx] = newSpectrum;
+  return {
+    ...stAdd,
+    uvvis: {
+      ...uvAdd,
+      spectraList: newSpectraList,
+      currentSpectrum: (0, _utils.normalizeSpectrumId)(uvAdd.selectedWaveLength) === normalizedSpectrumId ? newSpectrum : uvAdd.currentSpectrum
+    }
+  };
+};
+exports.updateHplcMsIntegrations = updateHplcMsIntegrations;
+const removeHplcMsPeak = (state, action) => {
+  const {
+    spectrumId,
+    peak
+  } = action.payload || {};
+  const {
+    uvvis
+  } = state;
+  const {
+    spectraList = [],
+    listWaveLength = []
+  } = uvvis;
+  const normalizedSpectrumId = (0, _utils.normalizeSpectrumId)(spectrumId);
+  const index = listWaveLength.map(waveLength => (0, _utils.normalizeSpectrumId)(waveLength)).indexOf(normalizedSpectrumId);
+  if (index === -1) return state;
+  const spectrum = spectraList[index];
+  if (!spectrum || !Array.isArray(spectrum.peaks) || !peak) return state;
+  const stPk = action.meta?.skipUvvisHistory ? state : recordUvvisEditBefore(state);
+  const uvPk = stPk.uvvis;
+  const spListPk = uvPk.spectraList;
+  const spectrumPk = spListPk[index];
+  const filteredPeaks = spectrumPk.peaks.filter(p => !(Math.abs(p.x - peak.x) < 1e-6 && Math.abs(p.y - peak.y) < 1e-6));
+  const updatedSpectrum = {
+    ...spectrumPk,
+    peaks: filteredPeaks
+  };
+  const updatedSpectraList = [...spListPk];
+  updatedSpectraList[index] = updatedSpectrum;
+  return {
+    ...stPk,
+    uvvis: {
+      ...uvPk,
+      spectraList: updatedSpectraList,
+      currentSpectrum: (0, _utils.normalizeSpectrumId)(uvPk.selectedWaveLength) === normalizedSpectrumId ? updatedSpectrum : uvPk.currentSpectrum
+    }
+  };
+};
+exports.removeHplcMsPeak = removeHplcMsPeak;
+const clearIntegrationAllHplcMs = (state, action = {}) => {
+  const {
+    uvvis
+  } = state;
+  if (!uvvis || !Array.isArray(uvvis.spectraList)) {
+    return state;
+  }
+  const stCl = action.meta?.skipUvvisHistory ? state : recordUvvisEditBefore(state);
+  const uvCl = stCl.uvvis;
+  const newSpectraList = uvCl.spectraList.map(spectrum => ({
+    ...spectrum,
+    integrations: []
+  }));
+  const newUvvis = {
+    ...uvCl,
+    spectraList: newSpectraList,
+    currentSpectrum: newSpectraList[uvCl.wavelengthIdx] || null
+  };
+  return {
+    ...stCl,
+    uvvis: newUvvis
+  };
+};
+exports.clearIntegrationAllHplcMs = clearIntegrationAllHplcMs;
+const clearAllPeaksHplcMs = (state, action = {}) => {
+  const {
+    uvvis
+  } = state;
+  if (!uvvis || !Array.isArray(uvvis.spectraList)) {
+    return state;
+  }
+  const stPkAll = action.meta?.skipUvvisHistory ? state : recordUvvisEditBefore(state);
+  const uvPkAll = stPkAll.uvvis;
+  const newSpectraList = uvPkAll.spectraList.map(spectrum => ({
+    ...spectrum,
+    peaks: []
+  }));
+  return {
+    ...stPkAll,
+    uvvis: {
+      ...uvPkAll,
+      spectraList: newSpectraList,
+      currentSpectrum: newSpectraList[uvPkAll.wavelengthIdx] || null
+    }
+  };
+};
+exports.clearAllPeaksHplcMs = clearAllPeaksHplcMs;

package/dist/reducers/reducer_integration.js

@@ -4,7 +4,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.integrationReducer = exports.default = void 0;
 var _reduxUndo = _interopRequireDefault(require("redux-undo"));
 var _action_type = require("../constants/action_type");
 var _integration = require("../helpers/integration");
@@ -37,7 +37,7 @@ const addToStack = (state, action) => {
     integrations
   } = state;
   let selectedIntegration = integrations[curveIdx];
-  if (selectedIntegration === false || selectedIntegration === undefined) {
+  if (!selectedIntegration) {
     selectedIntegration = defaultEmptyIntegration;
   }
   const {
@@ -53,7 +53,7 @@ const addToStack = (state, action) => {
     xL,
     xU
   } = xExtent;
-  if (!xL || !xU || xU - xL === 0) {
+  if (!Number.isFinite(xL) || !Number.isFinite(xU) || xU - xL === 0) {
     return state;
   }
   const area = (0, _integration.getArea)(xL, xU, data);
@@ -76,6 +76,22 @@ const addToStack = (state, action) => {
     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,
@@ -94,16 +110,251 @@ const rmFromStack = (state, action) => {
     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
     [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 = (0, _integration.splitAreaProportionally)(original.area, (0, _integration.getArea)(xL, splitX, data), (0, _integration.getArea)(splitX, xU, data));
+  const absParts = (0, _integration.splitAreaProportionally)(original.absoluteArea, (0, _integration.getAbsoluteArea)(xL, splitX, data), (0, _integration.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, (0, _integration.getArea)(xL, xU, data), (0, _integration.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) {
+    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 splitParts = buildSplitParts(original, xL, splitX, xU, shift, data, stack);
+  const [leftIntegration, rightIntegration] = splitParts;
+  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) {
+    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 = (0, _integration.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) {
+    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
   });
@@ -214,6 +465,12 @@ const integrationReducer = (state = initialState, action) => {
       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.ADD_VISUAL_SPLIT:
+      return addVisualSplitLine(state, action);
+    case _action_type.INTEGRATION.RM_VISUAL_SPLIT:
+      return removeVisualSplitLine(state, action);
     case _action_type.INTEGRATION.SET_REF:
       return setRef(state, action);
     case _action_type.INTEGRATION.SET_FKR:
@@ -230,5 +487,6 @@ const integrationReducer = (state = initialState, action) => {
       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;

package/dist/reducers/reducer_layout.js

@@ -14,7 +14,7 @@ const layoutReducer = (state = initialState, action) => {
     case _action_type.LAYOUT.UPDATE:
       return action.payload;
     case _action_type.MANAGER.RESETALL:
-      return action.payload.operation.layout;
+      return action.payload?.operation?.layout || state;
     default:
       return state;
   }