@complat/react-spectra-editor 0.10.13-alpha.5

package/dist/reducers/reducer_edit_peak.js

@@ -0,0 +1,111 @@
+'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');
+
+var _calc = require('../helpers/calc');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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 initialState = {
+  prevOffset: 0,
+  pos: [],
+  neg: []
+};
+
+var addToPos = function addToPos(state, action) {
+  var oriPosState = state.pos;
+  var oriNegState = state.neg;
+  var idxN = oriNegState.findIndex(function (n) {
+    return (0, _calc.almostEqual)(n.x, action.payload.x);
+  });
+  if (idxN >= 0) {
+    // rm the peak from oriNegState if it is already deleted.
+    var neg = [].concat(_toConsumableArray(oriNegState.slice(0, idxN)), _toConsumableArray(oriNegState.slice(idxN + 1)));
+    return Object.assign({}, state, { neg: neg });
+  }
+  var idxP = oriPosState.findIndex(function (p) {
+    return (0, _calc.almostEqual)(p.x, action.payload.x);
+  });
+  if (idxP < 0) {
+    // add the peak
+    var pos = [].concat(_toConsumableArray(oriPosState), [action.payload]);
+    return Object.assign({}, state, { pos: pos });
+  }
+  return state;
+};
+
+var rmFromPos = function rmFromPos(state, action) {
+  var oriPosState = state.pos;
+  var idx = oriPosState.findIndex(function (p) {
+    return p.x === action.payload.x;
+  });
+  var pos = [].concat(_toConsumableArray(oriPosState.slice(0, idx)), _toConsumableArray(oriPosState.slice(idx + 1)));
+  return Object.assign({}, state, { pos: pos });
+};
+
+var addToNeg = function addToNeg(state, action) {
+  var oriPosState = state.pos;
+  var oriNegState = state.neg;
+  var idxP = oriPosState.findIndex(function (n) {
+    return n.x === action.payload.x;
+  });
+  if (idxP >= 0) {
+    var pos = [].concat(_toConsumableArray(oriPosState.slice(0, idxP)), _toConsumableArray(oriPosState.slice(idxP + 1)));
+    return Object.assign({}, state, { pos: pos });
+  }
+  var idxN = oriNegState.findIndex(function (n) {
+    return n.x === action.payload.x;
+  });
+  if (idxN < 0) {
+    var neg = [].concat(_toConsumableArray(oriNegState), [action.payload]);
+    return Object.assign({}, state, { neg: neg });
+  }
+  return state;
+};
+
+var rmFromNeg = function rmFromNeg(state, action) {
+  var oriNegState = state.neg;
+  var idx = oriNegState.findIndex(function (n) {
+    return n.x === action.payload.x;
+  });
+  var neg = [].concat(_toConsumableArray(oriNegState.slice(0, idx)), _toConsumableArray(oriNegState.slice(idx + 1)));
+  return Object.assign({}, state, { neg: neg });
+};
+
+var editPeakReducer = function editPeakReducer() {
+  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+  var action = arguments[1];
+
+  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 Object.assign({}, state, action.payload);
+    case _action_type.MANAGER.RESETALL:
+      return initialState;
+    default:
+      return _undo_redo_config.undoRedoActions.indexOf(action.type) >= 0 ? Object.assign({}, state) : state;
+  }
+};
+
+var undoableEditPeakReducer = (0, _reduxUndo2.default)(editPeakReducer, _undo_redo_config.undoRedoConfig);
+
+exports.default = undoableEditPeakReducer;

package/dist/reducers/reducer_forecast.js

@@ -0,0 +1,113 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _action_type = require('../constants/action_type');
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var initialState = {
+  predictions: {
+    outline: {},
+    output: { result: [] }
+  }
+};
+
+var updateIrResl = function updateIrResl(stResl, plPred) {
+  var sma = plPred.sma,
+      identity = plPred.identity,
+      value = plPred.value;
+  var svgs = stResl.svgs;
+
+  var prevFgs = stResl.fgs;
+  var nextVal = _defineProperty({}, 'status' + identity, value);
+  var nextFgs = prevFgs.map(function (fg) {
+    if (fg.sma === sma) {
+      return Object.assign({}, fg, nextVal);
+    }
+    return fg;
+  });
+  var nextResult = { type: 'ir', fgs: nextFgs, svgs: svgs };
+  return nextResult;
+};
+
+var updateIrStatus = function updateIrStatus(state, action) {
+  var predictions = action.payload.predictions;
+  var _state$predictions = state.predictions,
+      outline = _state$predictions.outline,
+      output = _state$predictions.output;
+
+  var stResl = output.result[0];
+  var nextResl = updateIrResl(stResl, predictions);
+
+  return Object.assign({}, state, {
+    predictions: {
+      outline: outline,
+      output: {
+        result: [nextResl]
+      }
+    }
+  });
+};
+
+var updateNmrResl = function updateNmrResl(stResl, plPred) {
+  var idx = plPred.idx,
+      atom = plPred.atom,
+      identity = plPred.identity,
+      value = plPred.value;
+
+  var preResult = stResl;
+
+  var nextShifts = preResult.shifts.map(function (s, index) {
+    if (s.atom === atom && index === idx) {
+      return Object.assign({}, s, _defineProperty({}, 'status' + identity, value));
+    }
+    return s;
+  });
+  var nextResult = Object.assign({}, preResult, { shifts: nextShifts });
+  return nextResult;
+};
+
+var updateNmrStatus = function updateNmrStatus(state, action) {
+  var predictions = action.payload.predictions;
+  var _state$predictions2 = state.predictions,
+      outline = _state$predictions2.outline,
+      output = _state$predictions2.output;
+
+  var stResl = output.result[0];
+  var nextResl = updateNmrResl(stResl, predictions);
+
+  var newSt = Object.assign({}, state, {
+    predictions: {
+      outline: outline,
+      output: {
+        result: [nextResl]
+      }
+    }
+  });
+  return newSt;
+};
+
+var forecastReducer = function forecastReducer() {
+  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+  var action = arguments[1];
+
+  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;
+  }
+};
+
+exports.default = forecastReducer;

package/dist/reducers/reducer_integration.js

@@ -0,0 +1,136 @@
+'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 _integration = require('../helpers/integration');
+
+var _undo_redo_config = require('./undo_redo_config');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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 initialState = {
+  stack: [],
+  refArea: 1,
+  refFactor: 1,
+  shift: 0,
+  edited: false
+};
+
+var addToStack = function addToStack(state, action) {
+  var stack = state.stack,
+      refArea = state.refArea,
+      shift = state.shift;
+  var _action$payload = action.payload,
+      xExtent = _action$payload.xExtent,
+      data = _action$payload.data;
+  var xL = xExtent.xL,
+      xU = xExtent.xU;
+
+  if (!xL || !xU || xU - xL === 0) {
+    return state;
+  }
+  var area = (0, _integration.getArea)(xL, xU, data);
+  var defaultRefArea = stack.length === 0 ? area : refArea;
+  var newStack = [].concat(_toConsumableArray(stack), [{ xL: xL + shift, xU: xU + shift, area: area }]);
+  return Object.assign({}, state, { stack: newStack, refArea: defaultRefArea });
+};
+
+var rmFromStack = function rmFromStack(state, action) {
+  var stack = state.stack;
+  var _action$payload2 = action.payload,
+      xL = _action$payload2.xL,
+      xU = _action$payload2.xU,
+      xExtent = _action$payload2.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) {
+    return k.xL !== txL && k.xU !== txU;
+  });
+  return Object.assign({}, state, { stack: newStack });
+};
+
+var setRef = function setRef(state, action) {
+  var stack = state.stack;
+  var _action$payload3 = action.payload,
+      xL = _action$payload3.xL,
+      xU = _action$payload3.xU;
+
+  var ref = stack.filter(function (k) {
+    return k.xL === xL && k.xU === xU;
+  })[0];
+  var refArea = ref.area;
+  return Object.assign({}, state, { refArea: refArea });
+};
+
+var setFkr = function setFkr(state, action) {
+  var val = parseFloat(action.payload);
+  var refFactor = val < 0.01 ? 0.01 : val;
+  return Object.assign({}, state, { refFactor: refFactor });
+};
+
+var setShift = function setShift(state, action) {
+  var shift = action.payload.prevOffset;
+  return Object.assign({}, state, { shift: shift });
+};
+
+var resetAll = function resetAll(state, action) {
+  var newState = action.payload;
+  return Object.assign({}, state, newState);
+};
+
+var clearAll = function clearAll() {
+  return Object.assign({}, initialState, { edited: true });
+};
+
+var integrationReducer = function integrationReducer() {
+  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+  var action = arguments[1];
+
+  switch (action.type) {
+    case _action_type.UI.SWEEP.SELECT_INTEGRATION:
+      return addToStack(state, action);
+    case _action_type.INTEGRATION.RM_ONE:
+      return rmFromStack(state, action);
+    case _action_type.INTEGRATION.SET_REF:
+      return setRef(state, action);
+    case _action_type.INTEGRATION.SET_FKR:
+      return setFkr(state, action);
+    case _action_type.INTEGRATION.RESET_ALL_RDC:
+      return resetAll(state, action);
+    case _action_type.INTEGRATION.CLEAR_ALL:
+      return clearAll();
+    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;
+  }
+};
+
+var undoableIntegrationReducer = (0, _reduxUndo2.default)(integrationReducer, _undo_redo_config.undoRedoConfig);
+
+exports.default = undoableIntegrationReducer;

package/dist/reducers/reducer_jcamp.js

@@ -0,0 +1,74 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _action_type = require('../constants/action_type');
+
+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 initialState = {
+  others: [],
+  addOthersCb: false
+};
+
+var addOthers = function addOthers(state, _ref) {
+  var others = _ref.others,
+      addOthersCb = _ref.addOthersCb;
+
+  if (state.others.length > 5) return state;
+  var decoOthers = others.map(function (o) {
+    return Object.assign({}, o, { show: true });
+  });
+
+  return {
+    others: [].concat(_toConsumableArray(state.others), _toConsumableArray(decoOthers)).slice(0, 5),
+    addOthersCb: addOthersCb
+  };
+};
+
+var rmOthersOne = function rmOthersOne(state, payload) {
+  var idx = payload;
+  var others = state.others;
+
+  var nextOther = others.filter(function (_, i) {
+    return i !== idx;
+  });
+  return Object.assign({}, state, { others: nextOther });
+};
+
+var toggleShow = function toggleShow(state, payload) {
+  var idx = payload;
+  var others = state.others;
+
+  var nextOthers = others.map(function (o, i) {
+    if (i !== idx) return o;
+    var currentShow = o.show;
+    return Object.assign({}, o, { show: !currentShow });
+  });
+
+  return Object.assign({}, state, { others: nextOthers });
+};
+
+var layoutReducer = function layoutReducer() {
+  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+  var action = arguments[1];
+
+  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;
+  }
+};
+
+exports.default = layoutReducer;

package/dist/reducers/reducer_layout.js

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _action_type = require('../constants/action_type');
+
+var _list_layout = require('../constants/list_layout');
+
+var initialState = _list_layout.LIST_LAYOUT.C13;
+
+var layoutReducer = function layoutReducer() {
+  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+  var action = arguments[1];
+
+  switch (action.type) {
+    case _action_type.LAYOUT.UPDATE:
+      return action.payload;
+    case _action_type.MANAGER.RESETALL:
+      return action.payload.operation.layout;
+    default:
+      return state;
+  }
+};
+
+exports.default = layoutReducer;

package/dist/reducers/reducer_manager.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+// import { MANAGER } from '../constants/action_type';
+
+var initialState = {};
+
+var managerReducer = function managerReducer() {
+  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+  var action = arguments[1];
+
+  switch (action.type) {
+    default:
+      return state;
+  }
+};
+
+exports.default = managerReducer;

package/dist/reducers/reducer_meta.js

@@ -0,0 +1,30 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _action_type = require('../constants/action_type');
+
+var initialState = {
+  peaks: {
+    intervalL: null,
+    intervalR: null,
+    observeFrequency: null,
+    deltaX: null
+  }
+};
+
+var metaReducer = function metaReducer() {
+  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+  var action = arguments[1];
+
+  switch (action.type) {
+    case _action_type.META.UPDATE_PEAKS_RDC:
+      return Object.assign({}, state, action.payload);
+    default:
+      return state;
+  }
+};
+
+exports.default = metaReducer;

package/dist/reducers/reducer_multiplicity.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_scan.js

@@ -0,0 +1,55 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _action_type = require('../constants/action_type');
+
+var initialState = {
+  target: false,
+  count: 1,
+  isAuto: true
+};
+
+var setTarget = function setTarget(state, payload) {
+  return Object.assign({}, state, { target: payload });
+};
+
+var resetAll = function resetAll(state, payload) {
+  var scanCount = payload.scanCount,
+      scanEditTarget = payload.scanEditTarget;
+
+
+  return Object.assign({}, state, {
+    target: false,
+    count: parseInt(scanCount, 10),
+    isAuto: !scanEditTarget
+  });
+};
+
+var toggleIsAuto = function toggleIsAuto(state) {
+  return Object.assign({}, state, {
+    isAuto: !state.isAuto,
+    target: false
+  });
+};
+
+var scanReducer = function scanReducer() {
+  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+  var action = arguments[1];
+
+  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;
+  }
+};
+
+exports.default = scanReducer;