@complat/react-spectra-editor 0.11.3 → 0.11.4-beta.0

package/dist/reducers/reducer_multiplicity_bk.js

@@ -0,0 +1,131 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _reduxUndo = require('redux-undo');
+
+var _reduxUndo2 = _interopRequireDefault(_reduxUndo);
+
+var _action_type = require('../constants/action_type');
+
+var _undo_redo_config = require('./undo_redo_config');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var initialState = {
+  stack: [],
+  shift: 0,
+  smExtext: false,
+  edited: false
+};
+
+var setShift = function setShift(state, action) {
+  var shift = action.payload.prevOffset;
+  return Object.assign({}, state, { shift: shift });
+};
+
+var rmFromStack = function rmFromStack(state, action) {
+  var stack = state.stack;
+  var _action$payload = action.payload,
+      xL = _action$payload.xL,
+      xU = _action$payload.xU,
+      xExtent = _action$payload.xExtent;
+  var txL = 0,
+      txU = 0;
+
+  if (xL && xU) {
+    txL = xL; // rm click integration
+
+    txU = xU;
+  } else if (xExtent) {
+    var _ref = [xExtent.xL, xExtent.xU]; // rm click multiplicity
+
+    txL = _ref[0];
+    txU = _ref[1];
+  } else {
+    return state;
+  }
+  var newStack = stack.filter(function (k) {
+    var _ref2 = [k.xExtent.xL, k.xExtent.xU],
+        kxL = _ref2[0],
+        kxU = _ref2[1];
+
+    return kxL !== txL && kxU !== txU;
+  });
+  var newSmExtext = newStack[0] ? newStack[0].xExtent : false;
+  return Object.assign({}, state, { stack: newStack, smExtext: newSmExtext });
+};
+
+var updateMpyJ = function updateMpyJ(state, action) {
+  var payload = action.payload;
+  var xExtent = payload.xExtent,
+      value = payload.value;
+
+  if (!value && value !== '') return state;
+  var stack = state.stack;
+
+  var regx = /[^0-9.,-]/g;
+  var js = value.replace(regx, '').split(',').map(function (j) {
+    return parseFloat(j);
+  }).filter(function (j) {
+    return j;
+  });
+
+  var newStack = stack.map(function (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: js });
+    }
+    return k;
+  });
+  return Object.assign({}, state, { stack: newStack });
+};
+
+var clickMpyOne = function clickMpyOne(state, action) {
+  var payload = action.payload;
+
+  return Object.assign({}, state, { smExtext: payload });
+};
+
+var clearAll = function clearAll() {
+  return Object.assign({}, initialState, { edited: true });
+};
+
+var multiplicityReducer = function multiplicityReducer() {
+  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+  var action = arguments[1];
+
+  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();
+    case _action_type.MANAGER.RESETALL:
+      return state;
+    default:
+      return _undo_redo_config.undoRedoActions.indexOf(action.type) >= 0 ? Object.assign({}, state) : state;
+  }
+};
+
+var undoableMultiplicityReducer = (0, _reduxUndo2.default)(multiplicityReducer, _undo_redo_config.undoRedoConfig);
+
+exports.default = undoableMultiplicityReducer;

package/dist/reducers/reducer_shift_bk.js

@@ -0,0 +1,99 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _action_type = require('../constants/action_type');
+
+var _list_shift = require('../constants/list_shift');
+
+var _shift = require('../helpers/shift');
+
+var shiftNone = _list_shift.LIST_SHIFT_1H[0];
+
+var initialState = {
+  ref: shiftNone,
+  peak: false,
+  enable: true
+};
+
+var resetRef = function resetRef(payload) {
+  var shift = payload.shift,
+      layout = payload.layout;
+
+  if (!shift || !shift.solventName || !shift.solventValue) return shiftNone;
+
+  var name = shift.solventName;
+  var target = false;
+  var listShift = (0, _list_shift.getListShift)(layout);
+  listShift.forEach(function (l) {
+    if (l.name === name) {
+      target = l;
+    }
+  });
+  return target || shiftNone[0];
+};
+
+var resetEnable = function resetEnable(payload) {
+  var typ = payload.operation.typ;
+
+  switch (typ) {
+    case 'NMR':
+      return true;
+    default:
+      return false;
+  }
+};
+
+var shiftReducer = function shiftReducer() {
+  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+  var action = arguments[1];
+
+  switch (action.type) {
+    case _action_type.SHIFT.SET_REF:
+      return Object.assign({}, state, {
+        ref: action.payload,
+        enable: true
+      });
+    case _action_type.SHIFT.SET_PEAK:
+      {
+        var resX = (0, _shift.CalcResidualX)(state.ref, state.peak, action.payload);
+        var trueApex = (0, _shift.RealPts)([action.payload], resX)[0];
+        var isSamePt = state.peak.x === trueApex.x;
+        var truePeak = trueApex && trueApex.x && !isSamePt ? trueApex : false;
+        return Object.assign({}, state, {
+          peak: truePeak,
+          enable: true
+        });
+      }
+    case _action_type.SHIFT.RM_PEAK:
+      return Object.assign({}, state, {
+        peak: false,
+        enable: true
+      });
+    case _action_type.EDITPEAK.ADD_NEGATIVE:
+      {
+        var rmApex = state.peak.x === action.payload.x;
+        return !rmApex ? state : Object.assign({}, state, {
+          peak: false,
+          enable: true
+        });
+      }
+    case _action_type.LAYOUT.UPDATE:
+      return Object.assign({}, initialState, {
+        peak: false,
+        enable: state.enable
+      });
+    case _action_type.MANAGER.RESETSHIFT:
+      // case MANAGER.RESETALL:
+      return Object.assign({}, initialState, {
+        ref: resetRef(action.payload),
+        enable: resetEnable(action.payload)
+      });
+    default:
+      return state;
+  }
+};
+
+exports.default = shiftReducer;

package/dist/sagas/saga_edit_peak_bk.js

@@ -0,0 +1,84 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _effects = require('redux-saga/effects');
+
+var _action_type = require('../constants/action_type');
+
+var _shift = require('../helpers/shift');
+
+var _marked = /*#__PURE__*/regeneratorRuntime.mark(addVirtualFactor);
+
+var getShiftRef = function getShiftRef(state) {
+  return state.shift.ref;
+};
+var getShiftPeak = function getShiftPeak(state) {
+  return state.shift.peak;
+};
+var getEditPeak = function getEditPeak(state) {
+  return state.editPeak.present;
+};
+
+function addVirtualFactor(action) {
+  var origRef, origApex, origEPeak, payload, prevOffset, pos, neg, absOffset, relOffset, nextPos, nextNeg;
+  return regeneratorRuntime.wrap(function addVirtualFactor$(_context) {
+    while (1) {
+      switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 2;
+          return (0, _effects.select)(getShiftRef);
+
+        case 2:
+          origRef = _context.sent;
+          _context.next = 5;
+          return (0, _effects.select)(getShiftPeak);
+
+        case 5:
+          origApex = _context.sent;
+          _context.next = 8;
+          return (0, _effects.select)(getEditPeak);
+
+        case 8:
+          origEPeak = _context.sent;
+          payload = action.payload;
+          prevOffset = origEPeak.prevOffset, pos = origEPeak.pos, neg = origEPeak.neg;
+          absOffset = (0, _shift.FromManualToOffset)(origRef, origApex);
+          relOffset = prevOffset - absOffset;
+          nextPos = (0, _shift.VirtalPts)(pos, relOffset);
+          nextNeg = (0, _shift.VirtalPts)(neg, relOffset);
+          _context.next = 17;
+          return (0, _effects.put)({
+            type: _action_type.EDITPEAK.SHIFT,
+            payload: Object.assign({}, payload, {
+              prevOffset: absOffset,
+              pos: nextPos,
+              neg: nextNeg
+            })
+          });
+
+        case 17:
+        case 'end':
+          return _context.stop();
+      }
+    }
+  }, _marked);
+}
+
+var editPeakSagas = [(0, _effects.takeEvery)(_action_type.SHIFT.SET_REF, addVirtualFactor), (0, _effects.takeEvery)(_action_type.SHIFT.SET_PEAK, addVirtualFactor)];
+
+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
+-------------------------------------------------------------------
+
+*/

package/dist/sagas/saga_multiplicity_bk.js

@@ -0,0 +1,387 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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');
+
+var _marked = /*#__PURE__*/regeneratorRuntime.mark(selectMpy),
+    _marked2 = /*#__PURE__*/regeneratorRuntime.mark(addUiPeakToStack),
+    _marked3 = /*#__PURE__*/regeneratorRuntime.mark(rmPanelPeakFromStack),
+    _marked4 = /*#__PURE__*/regeneratorRuntime.mark(rmUiPeakFromStack),
+    _marked5 = /*#__PURE__*/regeneratorRuntime.mark(resetInitNmr),
+    _marked6 = /*#__PURE__*/regeneratorRuntime.mark(resetOne),
+    _marked7 = /*#__PURE__*/regeneratorRuntime.mark(selectMpyType);
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+var getMetaSt = function getMetaSt(state) {
+  return state.meta;
+};
+
+var getMultiplicitySt = function getMultiplicitySt(state) {
+  return state.multiplicity.present;
+};
+
+function selectMpy(action) {
+  var metaSt, mpySt, _action$payload, xExtent, yExtent, dataPks, shift, stack, xL, xU, yL, yU, peaks, newXExtemt, coupling, m, newStack, payload;
+
+  return regeneratorRuntime.wrap(function selectMpy$(_context) {
+    while (1) {
+      switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 2;
+          return (0, _effects.select)(getMetaSt);
+
+        case 2:
+          metaSt = _context.sent;
+          _context.next = 5;
+          return (0, _effects.select)(getMultiplicitySt);
+
+        case 5:
+          mpySt = _context.sent;
+          _action$payload = action.payload, xExtent = _action$payload.xExtent, yExtent = _action$payload.yExtent, dataPks = _action$payload.dataPks;
+          shift = mpySt.shift, stack = mpySt.stack;
+          xL = xExtent.xL, xU = xExtent.xU;
+          yL = yExtent.yL, yU = yExtent.yU;
+          peaks = dataPks.filter(function (p) {
+            return xL <= p.x && p.x <= xU && yL <= p.y && p.y <= yU;
+          });
+
+          peaks = peaks.map(function (pk) {
+            return { x: pk.x + shift, y: pk.y };
+          });
+          newXExtemt = { xL: xL + shift, xU: xU + shift };
+          coupling = (0, _multiplicity_calc.calcMpyCoup)(peaks, metaSt);
+          m = {
+            peaks: peaks,
+            xExtent: newXExtemt,
+            yExtent: yExtent,
+            mpyType: coupling.type,
+            js: coupling.js
+          };
+          newStack = [].concat(_toConsumableArray(stack), [m]);
+          payload = Object.assign({}, mpySt, { stack: newStack, smExtext: newXExtemt });
+          _context.next = 19;
+          return (0, _effects.put)({
+            type: _action_type.UI.SWEEP.SELECT_MULTIPLICITY_RDC,
+            payload: payload
+          });
+
+        case 19:
+        case 'end':
+          return _context.stop();
+      }
+    }
+  }, _marked);
+}
+
+function addUiPeakToStack(action) {
+  var metaSt, mpySt, shift, stack, smExtext, _action$payload2, x, y, newPeak, xL, xU, isDuplicate, newStack, payload;
+
+  return regeneratorRuntime.wrap(function addUiPeakToStack$(_context2) {
+    while (1) {
+      switch (_context2.prev = _context2.next) {
+        case 0:
+          _context2.next = 2;
+          return (0, _effects.select)(getMetaSt);
+
+        case 2:
+          metaSt = _context2.sent;
+          _context2.next = 5;
+          return (0, _effects.select)(getMultiplicitySt);
+
+        case 5:
+          mpySt = _context2.sent;
+          shift = mpySt.shift, stack = mpySt.stack, smExtext = mpySt.smExtext;
+          _action$payload2 = action.payload, x = _action$payload2.x, y = _action$payload2.y; // eslint-disable-line
+
+          if (!(!x || !y)) {
+            _context2.next = 10;
+            break;
+          }
+
+          return _context2.abrupt('return');
+
+        case 10:
+
+          x += shift;
+          newPeak = { x: x, y: y };
+          xL = smExtext.xL, xU = smExtext.xU;
+
+          if (!(x < xL || xU < x)) {
+            _context2.next = 15;
+            break;
+          }
+
+          return _context2.abrupt('return');
+
+        case 15:
+          isDuplicate = false;
+          newStack = stack.map(function (k) {
+            if (k.xExtent.xL === xL && k.xExtent.xU === xU) {
+              var existXs = k.peaks.map(function (pk) {
+                return pk.x;
+              });
+              if (existXs.indexOf(newPeak.x) >= 0) {
+                isDuplicate = true;
+                return k;
+              }
+              var newPks = [].concat(_toConsumableArray(k.peaks), [newPeak]);
+              var coupling = (0, _multiplicity_calc.calcMpyCoup)(newPks, metaSt);
+              return Object.assign({}, k, {
+                peaks: newPks,
+                mpyType: coupling.type,
+                js: coupling.js
+              });
+            }
+            return k;
+          });
+
+          if (!isDuplicate) {
+            _context2.next = 19;
+            break;
+          }
+
+          return _context2.abrupt('return');
+
+        case 19:
+          payload = Object.assign({}, mpySt, { stack: newStack });
+          _context2.next = 22;
+          return (0, _effects.put)({
+            type: _action_type.MULTIPLICITY.PEAK_ADD_BY_UI_RDC,
+            payload: payload
+          });
+
+        case 22:
+        case 'end':
+          return _context2.stop();
+      }
+    }
+  }, _marked2);
+}
+
+var rmPeakFromStack = function rmPeakFromStack(action, metaSt, mpySt) {
+  var _action$payload3 = action.payload,
+      peak = _action$payload3.peak,
+      xExtent = _action$payload3.xExtent;
+  var stack = mpySt.stack;
+
+  var newStack = stack.map(function (k) {
+    if (k.xExtent.xL === xExtent.xL && k.xExtent.xU === xExtent.xU) {
+      var newPks = k.peaks.filter(function (pk) {
+        return pk.x !== peak.x;
+      });
+      var coupling = (0, _multiplicity_calc.calcMpyCoup)(newPks, metaSt);
+      return Object.assign({}, k, {
+        peaks: newPks,
+        mpyType: coupling.type,
+        js: coupling.js
+      });
+    }
+    return k;
+  });
+  newStack = newStack.filter(function (k) {
+    return k.peaks.length !== 0;
+  });
+  if (newStack.length === 0) return Object.assign({}, mpySt, { stack: newStack, smExtext: false });
+  var noSmExtext = newStack.map(function (k) {
+    return k.xExtent.xL === xExtent.xL && k.xExtent.xU === xExtent.xU ? 1 : 0;
+  }).reduce(function (a, s) {
+    return a + s;
+  }) === 0;
+  var newSmExtext = noSmExtext ? newStack[0].xExtent : xExtent;
+  return Object.assign({}, mpySt, { stack: newStack, smExtext: newSmExtext });
+};
+
+function rmPanelPeakFromStack(action) {
+  var metaSt, mpySt, payload;
+  return regeneratorRuntime.wrap(function rmPanelPeakFromStack$(_context3) {
+    while (1) {
+      switch (_context3.prev = _context3.next) {
+        case 0:
+          _context3.next = 2;
+          return (0, _effects.select)(getMetaSt);
+
+        case 2:
+          metaSt = _context3.sent;
+          _context3.next = 5;
+          return (0, _effects.select)(getMultiplicitySt);
+
+        case 5:
+          mpySt = _context3.sent;
+          payload = rmPeakFromStack(action, metaSt, mpySt);
+          _context3.next = 9;
+          return (0, _effects.put)({
+            type: _action_type.MULTIPLICITY.PEAK_RM_BY_PANEL_RDC,
+            payload: payload
+          });
+
+        case 9:
+        case 'end':
+          return _context3.stop();
+      }
+    }
+  }, _marked3);
+}
+
+function rmUiPeakFromStack(action) {
+  var metaSt, mpySt, peak, xExtent, newAction, payload;
+  return regeneratorRuntime.wrap(function rmUiPeakFromStack$(_context4) {
+    while (1) {
+      switch (_context4.prev = _context4.next) {
+        case 0:
+          _context4.next = 2;
+          return (0, _effects.select)(getMetaSt);
+
+        case 2:
+          metaSt = _context4.sent;
+          _context4.next = 5;
+          return (0, _effects.select)(getMultiplicitySt);
+
+        case 5:
+          mpySt = _context4.sent;
+          peak = action.payload;
+          xExtent = mpySt.smExtext;
+          newAction = Object.assign({}, action, { payload: { peak: peak, xExtent: xExtent } });
+          payload = rmPeakFromStack(newAction, metaSt, mpySt);
+          _context4.next = 12;
+          return (0, _effects.put)({
+            type: _action_type.MULTIPLICITY.PEAK_RM_BY_UI_RDC,
+            payload: payload
+          });
+
+        case 12:
+        case 'end':
+          return _context4.stop();
+      }
+    }
+  }, _marked4);
+}
+
+function resetInitNmr(action) {
+  var multiplicity, mpySt;
+  return regeneratorRuntime.wrap(function resetInitNmr$(_context5) {
+    while (1) {
+      switch (_context5.prev = _context5.next) {
+        case 0:
+          multiplicity = action.payload.multiplicity;
+          _context5.next = 3;
+          return (0, _effects.select)(getMultiplicitySt);
+
+        case 3:
+          mpySt = _context5.sent;
+
+          if (!multiplicity) {
+            _context5.next = 7;
+            break;
+          }
+
+          _context5.next = 7;
+          return (0, _effects.put)({
+            type: _action_type.MULTIPLICITY.RESET_ALL_RDC,
+            payload: Object.assign({}, mpySt, multiplicity)
+          });
+
+        case 7:
+        case 'end':
+          return _context5.stop();
+      }
+    }
+  }, _marked5);
+}
+
+function resetOne(action) {
+  var xExtent, metaSt, mpySt, stack, newStack, payload;
+  return regeneratorRuntime.wrap(function resetOne$(_context6) {
+    while (1) {
+      switch (_context6.prev = _context6.next) {
+        case 0:
+          xExtent = action.payload;
+          _context6.next = 3;
+          return (0, _effects.select)(getMetaSt);
+
+        case 3:
+          metaSt = _context6.sent;
+          _context6.next = 6;
+          return (0, _effects.select)(getMultiplicitySt);
+
+        case 6:
+          mpySt = _context6.sent;
+          stack = mpySt.stack;
+          newStack = stack.map(function (k) {
+            if (k.xExtent.xL === xExtent.xL && k.xExtent.xU === xExtent.xU) {
+              var peaks = k.peaks;
+
+              var coupling = (0, _multiplicity_calc.calcMpyCoup)(peaks, metaSt);
+              return Object.assign({}, k, {
+                peaks: peaks,
+                mpyType: coupling.type,
+                js: coupling.js
+              });
+            }
+            return k;
+          });
+          payload = Object.assign({}, mpySt, { stack: newStack });
+          _context6.next = 12;
+          return (0, _effects.put)({
+            type: _action_type.MULTIPLICITY.RESET_ONE_RDC,
+            payload: payload
+          });
+
+        case 12:
+        case 'end':
+          return _context6.stop();
+      }
+    }
+  }, _marked6);
+}
+
+function selectMpyType(action) {
+  var mpySt, metaSt, _action$payload4, mpyType, xExtent, stack, newStack;
+
+  return regeneratorRuntime.wrap(function selectMpyType$(_context7) {
+    while (1) {
+      switch (_context7.prev = _context7.next) {
+        case 0:
+          _context7.next = 2;
+          return (0, _effects.select)(getMultiplicitySt);
+
+        case 2:
+          mpySt = _context7.sent;
+          _context7.next = 5;
+          return (0, _effects.select)(getMetaSt);
+
+        case 5:
+          metaSt = _context7.sent;
+          _action$payload4 = action.payload, mpyType = _action$payload4.mpyType, xExtent = _action$payload4.xExtent;
+          stack = mpySt.stack;
+          newStack = stack.map(function (k) {
+            var isTargetStack = k.xExtent.xL === xExtent.xL && k.xExtent.xU === xExtent.xU;
+            if (isTargetStack) return (0, _multiplicity_manual.calcMpyManual)(k, mpyType, metaSt);
+            return k;
+          });
+          _context7.next = 11;
+          return (0, _effects.put)({
+            type: _action_type.MULTIPLICITY.TYPE_SELECT_RDC,
+            payload: Object.assign({}, mpySt, { stack: newStack })
+          });
+
+        case 11:
+        case 'end':
+          return _context7.stop();
+      }
+    }
+  }, _marked7);
+}
+
+var 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)];
+
+exports.default = multiplicitySagas;