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

package/dist/helpers/multiplicity_calc.js

@@ -0,0 +1,117 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calcMpyCoup = exports.calcMpyJStr = exports.calcMpyCenter = undefined;
+
+var _jAnalyzer = require('../third_party/jAnalyzer');
+
+var _jAnalyzer2 = _interopRequireDefault(_jAnalyzer);
+
+var _multiplicity = require('./multiplicity');
+
+var _multiplicity_verify_basic = require('./multiplicity_verify_basic');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var centerX = function centerX(ps, shift) {
+  var pxs = ps.map(function (p) {
+    return p.x;
+  }).sort(function (a, b) {
+    return a - b;
+  });
+  var centIdx = (ps.length - 1) / 2;
+  if (centIdx < 0) return 0;
+  return pxs[centIdx] - shift;
+};
+
+var calcMpyCenter = function calcMpyCenter(ps, shift, typ) {
+  var count = ps.length;
+  var avgX = ps.reduce(function (sum, nxt) {
+    return sum + nxt.x;
+  }, 0) / ps.length - shift;
+  if (typ === 'm') return avgX;
+  if (count % 2 === 0) return avgX;
+  return centerX(ps, shift);
+};
+
+var calcMpyJStr = function calcMpyJStr(js) {
+  if (!Array.isArray(js) || js.length === 0) return ' - ';
+  var cJ = js.map(function (j) {
+    return j.toFixed(3);
+  }).join(', ');
+  return '' + cJ;
+};
+
+var calcMpyPeakWidth = function calcMpyPeakWidth(x, metaSt) {
+  var _metaSt$peaks = metaSt.peaks,
+      intervalL = _metaSt$peaks.intervalL,
+      intervalR = _metaSt$peaks.intervalR,
+      deltaX = _metaSt$peaks.deltaX;
+
+  var idxL = null;
+  intervalL.every(function (l, idx) {
+    if (l.x < x) {
+      idxL = idx - 1;
+      return false;
+    }
+    return true;
+  });
+  var idxR = null;
+  intervalR.every(function (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);
+};
+
+var calcMpyCoup = function calcMpyCoup(pks, metaSt) {
+  if (pks.length === 0) return { type: '', js: '' };
+  var orderPks = pks.sort(function (a, b) {
+    return b.x - a.x;
+  });
+  var observeFrequency = metaSt.peaks.observeFrequency;
+
+  var peaks = orderPks.map(function (p) {
+    return {
+      x: p.x,
+      intensity: p.y,
+      width: calcMpyPeakWidth(p.x, metaSt)
+    };
+  });
+
+  var signal = {
+    nbPeaks: peaks.length,
+    observe: observeFrequency,
+    nucleus: '1H',
+    peaks: peaks
+  };
+  _jAnalyzer2.default.compilePattern(signal);
+  var type = signal.multiplicity;
+  var js = signal.nmrJs ? signal.nmrJs.map(function (j) {
+    return j.coupling;
+  }).sort() : [];
+
+  var isTPCMatch = (0, _multiplicity_verify_basic.verifyTypePeakCount)(type, peaks);
+  if (!isTPCMatch) return { type: 'm', js: [] };
+
+  if (['s', 'm'].indexOf(type) >= 0) return { type: type, js: js };
+
+  var 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: type, js: js };
+};
+
+exports.calcMpyCenter = calcMpyCenter;
+exports.calcMpyJStr = calcMpyJStr;
+exports.calcMpyCoup = calcMpyCoup;

package/dist/helpers/multiplicity_complat.js

@@ -0,0 +1,126 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calcMpyComplat = undefined;
+
+var _multiplicity = require('./multiplicity');
+
+var calcMpyComplat = function calcMpyComplat(origPeaks) {
+  var peaks = origPeaks.sort(function (a, b) {
+    return a.x - b.x;
+  });
+  var count = peaks.length;
+  var itvs = (0, _multiplicity.getInterval)(peaks);
+  var gitvs = (0, _multiplicity.groupInterval)(itvs);
+  var type = 'm';
+  var js = [];
+  switch (count) {
+    case 1:
+      type = 's';
+      js = [];
+      break;
+    case 2:
+      if (gitvs.length === 1) {
+        type = 'd';
+        js = gitvs.map(function (g) {
+          return g.c;
+        });
+        break;
+      }
+      break;
+    case 3:
+      if (gitvs.length === 1) {
+        type = 't';
+        js = gitvs.map(function (g) {
+          return g.c;
+        });
+        break;
+      }
+      break;
+    case 4:
+      if (gitvs.length === 1) {
+        type = 'q';
+        js = gitvs.map(function (g) {
+          return g.c;
+        });
+        break;
+      } else if (gitvs.length === 2) {
+        type = 'dd';
+        js = gitvs.map(function (g) {
+          return g.c;
+        });
+        break;
+      }
+      break;
+    case 5:
+      if (gitvs.length === 1) {
+        type = 'quint';
+        js = gitvs.map(function (g) {
+          return g.c;
+        });
+        break;
+      }
+      break;
+    case 6:
+      if (gitvs.length === 1) {
+        type = 'h';
+        js = gitvs.map(function (g) {
+          return g.c;
+        });
+        break;
+      } else if (gitvs.length === 2) {
+        type = 'dt';
+        js = gitvs.map(function (g) {
+          return g.c;
+        });
+        break;
+      }
+      // td
+      break;
+    case 7:
+      if (gitvs.length === 1) {
+        type = 'sept';
+        js = gitvs.map(function (g) {
+          return g.c;
+        });
+        break;
+      } else if (gitvs.length === 3) {
+        type = 'ddd';
+        js = gitvs.map(function (g) {
+          return g.c;
+        });
+        break;
+      }
+      // td
+      break;
+    case 8:
+      if (gitvs.length === 1) {
+        type = 'o';
+        js = gitvs.map(function (g) {
+          return g.c;
+        });
+        break;
+      } else if (gitvs.length === 2) {
+        type = 'dq';
+        js = gitvs.map(function (g) {
+          return g.c;
+        });
+        break;
+      } else if (gitvs.length === 3) {
+        type = 'ddd';
+        js = gitvs.map(function (g) {
+          return g.c;
+        });
+        break;
+      }
+      // td
+      break;
+    default:
+      break;
+  }
+  return { type: type, js: js };
+};
+
+exports.calcMpyComplat = calcMpyComplat;

package/dist/helpers/multiplicity_manual.js

@@ -0,0 +1,94 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calcMpyManual = undefined;
+
+var _multiplicity = require('./multiplicity');
+
+var isTypeM = function isTypeM(mpyType) {
+  return mpyType === 'm';
+};
+var isTypeBasic = function isTypeBasic(mpyType) {
+  return _multiplicity.mpyBasicPatterns.slice(1).indexOf(mpyType) >= 0;
+};
+
+var outputTypeM = function outputTypeM(k) {
+  return Object.assign({}, k, { mpyType: 'm', js: [] });
+};
+
+var outputTypeBasic = function outputTypeBasic(k, mpyType, ivs, freq) {
+  var numIvs = ivs.length || 1;
+  var js = [freq * ivs.reduce(function (sum, x) {
+    return sum + x;
+  }) / numIvs];
+  return Object.assign({}, k, { mpyType: mpyType, js: js });
+};
+
+var outputTypeDD = function outputTypeDD(k, mpyType, ivs, freq) {
+  if (ivs.length >= 2) {
+    var js = [freq * ivs[0], freq * (ivs[0] + ivs[1])];
+    return Object.assign({}, k, { mpyType: mpyType, js: js });
+  }
+  return Object.assign({}, k, { mpyType: mpyType, js: [] });
+};
+
+var outputTypeDT = function outputTypeDT(k, mpyType, ivs, freq) {
+  if (ivs.length >= 4) {
+    var js = [freq * ivs[0], freq * (ivs[1] + ivs[2] + ivs[3])];
+    return Object.assign({}, k, { mpyType: mpyType, js: js });
+  }
+  return Object.assign({}, k, { mpyType: mpyType, js: [] });
+};
+
+var outputTypeTD = function outputTypeTD(k, mpyType, ivs, freq) {
+  if (ivs.length >= 2) {
+    var js = [freq * ivs[0], freq * (ivs[0] + ivs[1])];
+    return Object.assign({}, k, { mpyType: mpyType, js: js });
+  }
+  return Object.assign({}, k, { mpyType: mpyType, js: [] });
+};
+
+var outputTypeDQ = function outputTypeDQ(k, mpyType, ivs, freq) {
+  if (ivs.length >= 2) {
+    var js = [freq * ivs[0], freq * (ivs[0] + ivs[1])];
+    return Object.assign({}, k, { mpyType: mpyType, js: js });
+  } // only consider J = ([1,2], [1,3]), not J = ([1,2], [1,5])
+  return Object.assign({}, k, { mpyType: mpyType, js: [] });
+};
+
+var outputTypeQD = function outputTypeQD(k, mpyType, ivs, freq) {
+  if (ivs.length >= 2) {
+    var js = [freq * ivs[0], freq * (ivs[0] + ivs[1])];
+    return Object.assign({}, k, { mpyType: mpyType, js: js });
+  }
+  return Object.assign({}, k, { mpyType: mpyType, js: [] });
+};
+
+var outputTypeDDD = function outputTypeDDD(k, mpyType, ivs, freq) {
+  if (ivs.length >= 3) {
+    var js = [freq * ivs[0], freq * (ivs[0] + ivs[1]), freq * (ivs[0] + ivs[1] + ivs[2] + ivs[3])];
+    return Object.assign({}, k, { mpyType: mpyType, js: js });
+  }
+  return Object.assign({}, k, { mpyType: mpyType, js: [] });
+};
+
+var calcMpyManual = function calcMpyManual(k, mpyType, metaSt) {
+  var observeFrequency = metaSt.peaks.observeFrequency;
+
+  var freq = observeFrequency || 1.0;
+  var ivs = (0, _multiplicity.getInterval)(k.peaks);
+  if (ivs.length === 0) return Object.assign({}, k, { mpyType: 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: mpyType, js: [] });
+};
+
+exports.calcMpyManual = calcMpyManual;

package/dist/helpers/multiplicity_verify_basic.js

@@ -0,0 +1,196 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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); } }
+
+// ---------------------------------------------------------------
+// verifyTypePeakCount
+// ---------------------------------------------------------------
+
+var verifyTypePeakCount = function verifyTypePeakCount(type, peaks) {
+  var 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;
+  var limit = 1;
+  var mStr = type;
+  limit *= Math.pow(5, (mStr.match(/quint/g) || []).length);
+  mStr = mStr.replace(/quint/g, '');
+  limit *= Math.pow(7, (mStr.match(/sept/g) || []).length);
+  mStr = mStr.replace(/sept/g, '');
+  limit *= Math.pow(2, (mStr.match(/d/g) || []).length);
+  mStr = mStr.replace(/d/g, '');
+  limit *= Math.pow(3, (mStr.match(/t/g) || []).length);
+  mStr = mStr.replace(/t/g, '');
+  limit *= Math.pow(4, (mStr.match(/q/g) || []).length);
+  mStr = mStr.replace(/q/g, '');
+  limit *= Math.pow(6, (mStr.match(/h/g) || []).length);
+  mStr = mStr.replace(/h/g, '');
+  limit *= Math.pow(8, (mStr.match(/o/g) || []).length);
+  mStr = mStr.replace(/o/g, '');
+  limit *= Math.pow(9, (mStr.match(/n/g) || []).length);
+  mStr = mStr.replace(/n/g, '');
+  var isAdvanWrong = peaks.length > limit;
+  return !(isBasicWrong || isAdvanWrong);
+};
+
+// ---------------------------------------------------------------
+// Basic Multiplicity verification
+// ---------------------------------------------------------------
+
+var allowedTolerance = 0.15;
+
+var faktor = 1.1;
+
+var passRuleIntervalCounts = function passRuleIntervalCounts(oivs, limit) {
+  return oivs.length === limit;
+};
+
+var getRuleParams = function getRuleParams(oivs, metaSt) {
+  var _metaSt$peaks = metaSt.peaks,
+      deltaX = _metaSt$peaks.deltaX,
+      observeFrequency = _metaSt$peaks.observeFrequency;
+
+  var sivs = [].concat(_toConsumableArray(oivs)).sort(function (a, b) {
+    return b - a;
+  });
+  var ref = sivs[0];
+  var rDeltaX = Math.abs(2 * deltaX / ref);
+  var tTolerance = rDeltaX > allowedTolerance ? rDeltaX : allowedTolerance;
+  var tolerance = Math.abs(tTolerance * faktor);
+  var roivs = oivs.map(function (oiv) {
+    return oiv / ref;
+  });
+  var rsivs = sivs.map(function (siv) {
+    return siv / ref;
+  });
+  return {
+    roivs: roivs, rsivs: rsivs, tolerance: tolerance, observeFrequency: observeFrequency
+  };
+};
+
+var verifyTypeT = function verifyTypeT(type, js, oivs, metaSt) {
+  if (!passRuleIntervalCounts(oivs, 2)) return { type: 'm', js: [] };
+
+  var _getRuleParams = getRuleParams(oivs, metaSt),
+      rsivs = _getRuleParams.rsivs,
+      tolerance = _getRuleParams.tolerance;
+
+  var isT = Math.abs(rsivs[0] - rsivs[1]) < tolerance;
+  if (isT) return { type: type, js: js };
+  return { type: 'm', js: [] };
+};
+
+var verifyTypeQ = function verifyTypeQ(type, js, oivs, metaSt) {
+  if (!passRuleIntervalCounts(oivs, 3)) return { type: 'm', js: [] };
+
+  var _getRuleParams2 = getRuleParams(oivs, metaSt),
+      roivs = _getRuleParams2.roivs,
+      rsivs = _getRuleParams2.rsivs,
+      tolerance = _getRuleParams2.tolerance,
+      observeFrequency = _getRuleParams2.observeFrequency;
+
+  var isQ = Math.abs(rsivs[0] - rsivs[2]) < tolerance;
+  if (isQ) return { type: type, js: js };
+
+  var isDD = Math.abs(roivs[0] - roivs[2]) < tolerance && Math.abs(roivs[0] - roivs[1]) >= tolerance;
+  var ddJs = [oivs[0] * observeFrequency, (oivs[0] + oivs[1]) * observeFrequency];
+  if (isDD) return { type: 'dd', js: ddJs };
+  return { type: 'm', js: [] };
+};
+
+var verifyTypeQuint = function verifyTypeQuint(type, js, oivs, metaSt) {
+  if (!passRuleIntervalCounts(oivs, 4)) return { type: 'm', js: [] };
+
+  var _getRuleParams3 = getRuleParams(oivs, metaSt),
+      rsivs = _getRuleParams3.rsivs,
+      tolerance = _getRuleParams3.tolerance;
+
+  var isQuint = Math.abs(rsivs[0] - rsivs[3]) < tolerance;
+  if (isQuint) return { type: type, js: js };
+  return { type: 'm', js: [] };
+};
+
+var verifyTypeH = function verifyTypeH(type, js, oivs, metaSt) {
+  if (!passRuleIntervalCounts(oivs, 5)) return { type: 'm', js: [] };
+
+  var _getRuleParams4 = getRuleParams(oivs, metaSt),
+      roivs = _getRuleParams4.roivs,
+      rsivs = _getRuleParams4.rsivs,
+      tolerance = _getRuleParams4.tolerance,
+      observeFrequency = _getRuleParams4.observeFrequency;
+
+  var isH = Math.abs(rsivs[0] - rsivs[4]) < tolerance;
+  if (isH) return { type: type, js: js };
+  var 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;
+  var tdJs = [oivs[0] * observeFrequency, (oivs[0] + oivs[1]) * observeFrequency];
+  if (isTD) return { type: 'td', js: tdJs };
+  var 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;
+  var dt1Js = [oivs[0] * observeFrequency, (oivs[1] + oivs[2] + oivs[3]) * observeFrequency];
+  if (isDT1) return { type: 'dt', js: dt1Js };
+  var 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;
+  var dt2Js = [oivs[0] * observeFrequency, (oivs[1] + oivs[2] + oivs[3]) * observeFrequency];
+  if (isDT2) return { type: 'dt', js: dt2Js };
+  return { type: 'm', js: [] };
+};
+
+var verifyTypeSept = function verifyTypeSept(type, js, oivs, metaSt) {
+  if (!passRuleIntervalCounts(oivs, 6)) return { type: 'm', js: [] };
+
+  var _getRuleParams5 = getRuleParams(oivs, metaSt),
+      roivs = _getRuleParams5.roivs,
+      rsivs = _getRuleParams5.rsivs,
+      tolerance = _getRuleParams5.tolerance,
+      observeFrequency = _getRuleParams5.observeFrequency;
+
+  var isSept = Math.abs(rsivs[0] - rsivs[5]) < tolerance;
+  if (isSept) return { type: type, js: js };
+
+  var 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;
+  var 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: [] };
+};
+
+var verifyTypeO = function verifyTypeO(type, js, oivs, metaSt) {
+  if (!passRuleIntervalCounts(oivs, 7)) return { type: 'm', js: [] };
+
+  var _getRuleParams6 = getRuleParams(oivs, metaSt),
+      roivs = _getRuleParams6.roivs,
+      rsivs = _getRuleParams6.rsivs,
+      tolerance = _getRuleParams6.tolerance,
+      observeFrequency = _getRuleParams6.observeFrequency;
+
+  var isO = Math.abs(rsivs[0] - rsivs[6]) < tolerance;
+  if (isO) return { type: type, js: js };
+
+  var 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;
+  var qdJs = [oivs[0] * observeFrequency, (oivs[0] + oivs[1]) * observeFrequency];
+  if (isQD) return { type: 'qd', js: qdJs };
+
+  var 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;
+  var dq1Js = [oivs[0] * observeFrequency, (oivs[0] + oivs[1]) * observeFrequency];
+  if (isDQ1) return { type: 'dq', js: dq1Js };
+
+  var 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;
+  var dq2Js = [oivs[0] * observeFrequency, (oivs[0] + oivs[1] + oivs[2] + oivs[3]) * observeFrequency];
+  if (isDQ2) return { type: 'dq', js: dq2Js };
+
+  var 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;
+  var 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 };
+
+  var 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;
+  var 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.verifyTypeT = verifyTypeT;
+exports.verifyTypeQ = verifyTypeQ;
+exports.verifyTypeQuint = verifyTypeQuint;
+exports.verifyTypeH = verifyTypeH;
+exports.verifyTypeSept = verifyTypeSept;
+exports.verifyTypeO = verifyTypeO;
+exports.verifyTypePeakCount = verifyTypePeakCount;

package/dist/helpers/shift.js

@@ -0,0 +1,48 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RealPts = exports.VirtalPts = exports.CalcResidualX = exports.FromManualToOffset = undefined;
+
+var _list_shift = require('../constants/list_shift');
+
+var shiftNone = _list_shift.LIST_SHIFT_13C[0];
+
+var FromManualToOffset = function FromManualToOffset(ref, peak) {
+  if (!peak || ref.name === shiftNone.name) return 0;
+  var offset = peak.x - ref.value;
+  return offset || 0;
+};
+
+var CalcResidualX = function CalcResidualX(origRef, origApex, nextApex) {
+  if (!nextApex) return 0.0; // nextApex = false
+  if (origRef.name === shiftNone.name) return 0.0;
+  var origApexX = origApex ? origApex.x : 0.0;
+  var origShift = origApexX === 0.0 ? 0.0 : origRef.value; // orig shift
+  var resX = origShift - origApexX;
+  return resX;
+};
+
+var VirtalPts = function VirtalPts(pts, resX) {
+  return pts.map(function (pt) {
+    return Object.assign({
+      x: pt.x + resX,
+      y: pt.y
+    });
+  });
+};
+
+var RealPts = function RealPts(pts, resX) {
+  return pts.map(function (pt) {
+    return Object.assign({
+      x: pt.x - resX,
+      y: pt.y
+    });
+  });
+};
+
+exports.FromManualToOffset = FromManualToOffset;
+exports.CalcResidualX = CalcResidualX;
+exports.VirtalPts = VirtalPts;
+exports.RealPts = RealPts;

package/dist/helpers/zoom.js

@@ -0,0 +1,32 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _d = require('d3');
+
+var d3 = _interopRequireWildcard(_d);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+var resetZoom = function resetZoom(main) {
+  main.svg.call(main.zoom.transform, d3.zoomIdentity);
+  main.svg.selectAll('.brush').call(main.brush.move, null);
+};
+
+var MountZoom = function MountZoom(main, zoomed) {
+  var zoomedCb = function zoomedCb() {
+    return zoomed(main);
+  };
+  var resetZoomCb = function resetZoomCb() {
+    d3.event.stopPropagation();
+    d3.event.preventDefault();
+    resetZoom(main);
+  };
+
+  main.zoom.on('zoom', zoomedCb);
+  main.svg.call(main.zoom).on('contextmenu.zoom', resetZoomCb);
+};
+
+exports.default = MountZoom;