peptide-score 2.3.14

package/src/chargePeptide.js

@@ -0,0 +1,48 @@
+import { getAA } from './getAA';
+
+// SOURCE: https://en.wikipedia.org/wiki/Amino_acid
+
+export function chargePeptide(mf, options = {}) {
+  if (Array.isArray(mf)) {
+    for (let i = 0; i < mf.length; i++) {
+      mf[i] = chargeOnePeptide(mf[i], options);
+    }
+    return mf;
+  } else {
+    return chargeOnePeptide(mf, options);
+  }
+}
+
+function chargeOnePeptide(mf, options) {
+  const { pH = 0 } = options;
+  // we will allow to charge the peptide at a specific pH
+
+  // first amino acids (N-terminal)
+  if (mf.match(/^H[A-Z][a-z]{2}/)) {
+    let firstAA = mf.replace(/^H([A-Z][a-z]{2}).*/, '$1');
+    if (getAA(firstAA) && pH < getAA(firstAA).pKaN) {
+      mf = mf.replace(/^H([^+])/, 'H+H$1');
+    }
+  }
+
+  // last amino acids (C-terminal)
+  if (mf.match(/[A-Z][a-z]{2}OH$/)) {
+    let lastAA = mf.replace(/.*([A-Z][a-z]{2})OH$/, '$1');
+    if (getAA(lastAA) && pH > getAA(lastAA).pKaC) {
+      mf = mf.replace(/OH$/, 'O-');
+    }
+  }
+
+  // basic AA
+  if (pH < getAA('Arg').sc.pKa) mf = mf.replaceAll(/(Arg)(?!\()/g, '$1(H+)');
+  if (pH < getAA('His').sc.pKa) mf = mf.replaceAll(/(His)(?!\()/g, '$1(H+)');
+  if (pH < getAA('Lys').sc.pKa) mf = mf.replaceAll(/(Lys)(?!\()/g, '$1(H+)');
+
+  // acid AA
+  if (pH > getAA('Asp').sc.pKa) mf = mf.replaceAll(/(Asp)(?!\()/g, '$1(H-1-)');
+  if (pH > getAA('Glu').sc.pKa) mf = mf.replaceAll(/(Glu)(?!\()/g, '$1(H-1-)');
+
+  if (pH > getAA('Cys').sc.pKa) mf = mf.replaceAll(/(Cys)(?!\()/g, '$1(H-1-)');
+
+  return mf;
+}

package/src/digestPeptide.js

@@ -0,0 +1,87 @@
+/*
+Iotuibs:
+* minMissed (default: 0)
+* maxMissed (default: 0)
+* minResidue: 0;
+* maxResidue: infinity
+* enzyme: chymotrypsin, trypsin, glucph4, glucph8, thermolysin, cyanogenbromide : Mandatory, no default value !
+ */
+
+export function digestPeptide(sequence, options = {}) {
+  sequence = sequence.replace(/^H([^a-z])/, '$1').replace(/OH$/, '');
+  options.enzyme = options.enzyme || 'trypsin';
+  if (options.minMissed === undefined) options.minMissed = 0;
+  if (options.maxMissed === undefined) options.maxMissed = 0;
+  if (options.minResidue === undefined) options.minResidue = 0;
+  if (options.maxResidue === undefined) options.maxResidue = Number.MAX_VALUE;
+  let regexp = getRegexp(options.enzyme);
+  let fragments = sequence.replace(regexp, '$1 ').split(/ /).filter(Boolean);
+
+  {
+    let from = 0;
+    for (let i = 0; i < fragments.length; i++) {
+      let nbResidue = fragments[i]
+        .replaceAll(/([A-Z][a-z]{2})/g, ' $1')
+        .split(/ /)
+        .filter(Boolean).length;
+      fragments[i] = {
+        sequence: fragments[i],
+        nbResidue,
+        from,
+        to: from + nbResidue - 1,
+      };
+      from += nbResidue;
+    }
+  }
+
+  let results = [];
+
+  for (let i = 0; i < fragments.length - options.minMissed; i++) {
+    for (
+      let j = options.minMissed;
+      j <= Math.min(options.maxMissed, fragments.length - i - 1);
+      j++
+    ) {
+      let fragment = '';
+      let nbResidue = 0;
+      for (let k = i; k <= i + j; k++) {
+        fragment += fragments[k].sequence;
+        nbResidue += fragments[k].nbResidue;
+      }
+      let from = fragments[i].from + 1;
+      let to = fragments[i + j].to + 1;
+      if (
+        fragment &&
+        nbResidue >= options.minResidue &&
+        nbResidue <= options.maxResidue
+      ) {
+        results.push(`H${fragment}OH$D${from}>${to}`);
+      }
+    }
+  }
+
+  return results;
+}
+
+function getRegexp(enzyme) {
+  switch (enzyme.toLowerCase().replaceAll(/[^\da-z]/g, '')) {
+    case 'chymotrypsin':
+      return /(Phe|Tyr|Trp)(?!Pro)/g;
+    case 'trypsin':
+      return /(Lys|Arg)(?!Pro)/g;
+    case 'lysc':
+      return /(Lys)(?!Pro)/g;
+    case 'glucph4':
+      return /(Glu)(?!Pro|Glu)/g;
+    case 'glucph8':
+      return /(Asp|Glu)(?!Pro|Glu)/g;
+    case 'thermolysin': // N-term of  Leu, Phe, Val, Ile, Ala, Met
+      return /()(?=Ile|Leu|Val|Ala|Met|Phe)/g;
+    case 'cyanogenbromide':
+      return /(Met)/g;
+    case 'any':
+      return /()(?=[A-Z][a-z]{2})/g;
+    default:
+      throw new Error(`Digestion enzyme: ${enzyme} is unknown`);
+  }
+}

package/src/generatePeptideFragments.js

@@ -0,0 +1,89 @@
+export function generatePeptideFragments(mf, options) {
+  if (options === undefined) {
+    options = {
+      a: false,
+      b: true,
+      c: false,
+      x: false,
+      y: true,
+      z: false,
+      i: false,
+      ya: false,
+      yb: false,
+      yc: false,
+      zc: false,
+    };
+  }
+  options.maxInternal = options.maxInternal || Number.MAX_VALUE;
+  options.minInternal = options.minInternal || 0;
+
+  let mfs = [];
+  // need to allow 0-9 to deal with neutral loss
+  let mfparts = mf
+    .replaceAll(/([\d)a-z])([A-Z][a-z](?=[a-z]))/g, '$1 $2')
+    .split(/ /);
+
+  let nTerm = '';
+  let cTerm = '';
+
+  if (mfparts[0].startsWith('(')) {
+    nTerm += mfparts[0];
+    mfparts = mfparts.splice(1);
+  }
+
+  if (mfparts.at(-1).includes('(')) {
+    cTerm += mfparts.at(-1).replace(/^[^()]*/, '');
+    mfparts[mfparts.length - 1] = mfparts.at(-1).replace(/\(.*/, '');
+  }
+
+  for (let i = 1; i < mfparts.length; i++) {
+    nTerm += mfparts[i - 1];
+    cTerm = mfparts[mfparts.length - i] + cTerm;
+    addNTerm(mfs, nTerm, i, options);
+    addCTerm(mfs, cTerm, i, options);
+    if (options.i) mfs.push(`${mfparts[i]}HC-1O-1(+1)$i:${mfparts[i]}`);
+
+    if (options.ya || options.yb || options.yc || options.zc) {
+      // we have double fragmentations
+      for (
+        let j = i + 1;
+        j < Math.min(mfparts.length, options.maxInternal + i + 1);
+        j++
+      ) {
+        let iTerm = '';
+        if (j - i >= options.minInternal) {
+          for (let k = i; k < j; k++) {
+            iTerm += mfparts[k];
+          }
+          addITerm(mfs, iTerm, mfparts.length - i, j, options);
+        }
+      }
+    }
+  }
+
+  // todo does this make sense ??? I think we should remote those 3 lines
+  if (mfs.length === 0) {
+    mfs = mfs.concat([mf]);
+  }
+
+  return mfs;
+}
+
+function addNTerm(mfs, nTerm, i, options) {
+  if (options.a) mfs.push(`${nTerm}C-1O-1(+1)$a${i}`);
+  if (options.b) mfs.push(`${nTerm}(+1)$b${i}`);
+  if (options.c) mfs.push(`${nTerm}NH3(+1)$c${i}`);
+}
+
+function addITerm(mfs, iTerm, i, j, options) {
+  if (options.ya) mfs.push(`H${iTerm}C-1O-1(+1)$a${j}y${i}`);
+  if (options.yb) mfs.push(`H${iTerm}(+1)$b${j}y${i}`);
+  if (options.yc) mfs.push(`H${iTerm}NH3(+1)$c${j}y${i}`);
+  if (options.zc) mfs.push(`N-1${iTerm}NH3(+1)$c${j}z${i}`);
+}
+
+function addCTerm(mfs, cTerm, i, options) {
+  if (options.x) mfs.push(`CO(+1)${cTerm}$x${i}`);
+  if (options.y) mfs.push(`H2(+1)${cTerm}$y${i}`);
+  if (options.z) mfs.push(`N-1H-1(+1)${cTerm}$z${i}`);
+}

package/src/getAA.js

@@ -0,0 +1,18 @@
+import { aminoAcids } from './aminoAcids';
+
+export function getAA(code) {
+  if (code.length === 1) {
+    for (let i = 0; i < aminoAcids.length; i++) {
+      if (aminoAcids[i].aa1 === code) {
+        return aminoAcids[i];
+      }
+    }
+  }
+  if (code.length === 3) {
+    for (let i = 0; i < aminoAcids.length; i++) {
+      if (aminoAcids[i].aa3 === code) {
+        return aminoAcids[i];
+      }
+    }
+  }
+}

package/src/index.js

@@ -0,0 +1,37 @@
+import { aminoAcids } from './aminoAcids';
+import * as IEP from './isoElectricPoint';
+import { splitPeptide } from './splitPeptide.js';
+
+export * from './allowNeutralLoss.js';
+export * from './chargePeptide.js';
+export * from './sequenceToMF.js';
+export * from './generatePeptideFragments.js';
+export * from './digestPeptide.js';
+export * from './splitPeptide.js';
+
+export function getInfo() {
+  return aminoAcids;
+}
+
+// sequence should be in the "right" format like HAlaGlyProOH
+
+export function calculateIEP(sequence) {
+  let aas = splitPeptide(sequence);
+  let result = IEP.calculateIEP(aas);
+  return result;
+}
+
+export function calculateIEPChart(sequence) {
+  let aas = splitPeptide(sequence);
+  let result = IEP.calculateChart(aas);
+  return result;
+}
+
+export function getColorForIEP(iep) {
+  return IEP.getColor(iep);
+}
+
+export function calculateCharge(sequence, ph) {
+  let aas = splitPeptide(sequence);
+  return IEP.calculateCharge(aas, ph);
+}

package/src/isoElectricPoint.js

@@ -0,0 +1,124 @@
+import { aminoAcids } from './aminoAcids';
+
+// we will convert the data to an object to be much faster
+let aaObject = {};
+for (let i = 0; i < aminoAcids.length; i++) {
+  aaObject[aminoAcids[i].aa3] = aminoAcids[i];
+}
+
+export function calculateCharge(aas, pH = 7) {
+  let combined = combine(aas);
+  if (!combined) return;
+  let charge = calculateForPh(combined, pH);
+  return Math.round(charge * 1000) / 1000;
+}
+
+// this methods required an array of aas
+
+export function calculateIEP(aas) {
+  let combined = combine(aas);
+  if (!combined) return;
+  let first = 0;
+  let last = 14;
+  let current = 14;
+  let previous = 0;
+  let currentCharge;
+  while (Math.abs(current - previous) > 0.0001) {
+    previous = current;
+    current = (last + first) / 2;
+    currentCharge = calculateForPh(combined, current);
+    if (currentCharge > 0) {
+      first = current;
+    } else if (currentCharge < 0) {
+      last = current;
+    } else {
+      previous = current;
+    }
+  }
+  return Math.round(current * 1000) / 1000;
+}
+
+export function calculateChart(aas) {
+  let combined = combine(aas);
+  if (!combined) return;
+  let y = [];
+  let x = [];
+  let yAbs = [];
+  for (let i = 0; i <= 14; i = i + 0.01) {
+    let charge = calculateForPh(combined, i);
+    x.push(i);
+    y.push(charge);
+    yAbs.push(Math.abs(charge));
+  }
+  combined.x = x;
+  combined.y = y;
+  combined.yAbs = yAbs;
+
+  return combined;
+}
+
+function calculateForPh(combined, pH) {
+  let total = 0;
+  total += 1 / (1 + 10 ** (pH - combined.first));
+  total += -1 / (1 + 10 ** (combined.last - pH));
+  for (let key in combined.acid) {
+    total += -combined.acid[key] / (1 + 10 ** (aaObject[key].sc.pKa - pH));
+  }
+  for (let key in combined.basic) {
+    total += combined.basic[key] / (1 + 10 ** (pH - aaObject[key].sc.pKa));
+  }
+  return total;
+}
+
+// we will combine the amino acids
+function combine(aas) {
+  let combined = {};
+  if (aaObject[aas[0]]) {
+    combined.first = aaObject[aas[0]].pKaN;
+  } else {
+    return;
+  }
+  if (aaObject[aas.at(-1)]) {
+    combined.last = aaObject[aas.at(-1)].pKaC;
+  } else {
+    return;
+  }
+  combined.basic = {};
+  combined.acid = {};
+  for (let i = 0; i < aas.length; i++) {
+    let currentAA = aas[i];
+    if (!aaObject[currentAA]) return;
+    if (aaObject[currentAA].sc && aaObject[currentAA].sc.type) {
+      if (aaObject[currentAA].sc.type === 'positive') {
+        if (!combined.basic[currentAA]) {
+          combined.basic[currentAA] = 0;
+        }
+        combined.basic[currentAA]++;
+      } else if (aaObject[currentAA].sc.type === 'negative') {
+        if (!combined.acid[currentAA]) {
+          combined.acid[currentAA] = 0;
+        }
+        combined.acid[currentAA]++;
+      }
+    }
+  }
+  return combined;
+}
+
+/*
+ We can generate a color based on iep
+ 0 -> 7 means that at pH 7 it is charged negatively (blue)
+ 7 -> 14 means that at pH7 it is charged positively (red)
+ */
+export function getColor(iep) {
+  if (iep < 7) {
+    if (iep < 3) iep = 3;
+    let white = Math.round(255 - (7 - iep) * (200 / 4));
+    return `rgb(${white},${white},255)`;
+  } else if (iep > 7) {
+    if (iep > 11) iep = 11;
+    let white = Math.round(255 - (iep - 7) * (200 / 4));
+    return `rgb(255,${white},${white})`;
+  }
+  return 'rgb(255,255,255)';
+}

package/src/sequenceToMF.js

@@ -0,0 +1,96 @@
+import { ensureUppercaseSequence } from 'mf-utilities';
+
+import { aminoAcids } from './aminoAcids';
+
+export function sequenceToMF(mf) {
+  if (mf === '') return '';
+  mf = ensureUppercaseSequence(mf);
+  // this function will check if it is a sequence of aa in 1 letter or 3 letters and convert them if it is the case
+  // it could be a multiline mf !
+  // if it is a multiline we could make some "tricks" ...
+
+  let newMF = mf;
+  // SEQRES   1 B  256  MET PRO VAL GLU ILE THR VAL LYS GLU LEU LEU GLU ALA
+  // SEQRES   2 B  256  GLY VAL HIS PHE GLY HIS GLU ARG LYS ARG TRP ASN PRO
+  // or
+  // MET PRO VAL GLU ILE THR VAL LYS GLU LEU LEU GLU ALA
+  // GLY VAL HIS PHE GLY HIS GLU ARG LYS ARG TRP ASN PRO
+  if (mf.search(/(?:[A-Z]{3} ){2}[A-Z]{3}/) > -1) {
+    // this is a PDB !
+    let tmpmf = mf.replaceAll(/[\n\r]+/g, ' ');
+    tmpmf = tmpmf.replaceAll(/(SEQRES|\d+| [A-Z] | [\dA-Z]{4-50})/g, '');
+    // we need to correct the uppercase / lowercase
+    let parts = tmpmf.split(' ');
+    newMF = 'H';
+    for (let i = 0; i < parts.length; i++) {
+      newMF += parts[i].slice(0, 1) + parts[i].slice(1).toLowerCase();
+    }
+    newMF += 'OH';
+  } else if (mf.includes('(') && isOneLetterCode(mf)) {
+    // we expect one-letter code with modification
+    newMF = '';
+    let nTerminal = 'H';
+    let cTerminal = 'OH';
+    let parenthesisCounter = 0;
+    for (let i = 0; i < mf.length; i++) {
+      let currentSymbol = mf[i];
+      if (
+        currentSymbol === '(' ||
+        currentSymbol === ')' ||
+        parenthesisCounter > 0
+      ) {
+        if (currentSymbol === '(') {
+          parenthesisCounter++;
+          if (i === 0) nTerminal = '';
+        }
+        if (currentSymbol === ')') {
+          parenthesisCounter--;
+          if (i === mf.length - 1) cTerminal = '';
+        }
+        newMF += currentSymbol;
+        continue;
+      }
+      newMF += convertAA1To3(currentSymbol);
+    }
+    newMF = nTerminal + newMF + cTerminal;
+  } else if (mf.search(/[A-Za-z][\da-z]/) === -1) {
+    // UNIPROT
+    //   370        380        390        400        410        420
+    //GFKPNLRKTF VSGLFRESCG AHFYRGVDVK PFYIKKPVDN LFALMLILNR LRGWGVVGGM
+    //
+    //    430        440        450        460        470        480
+    //SDPRLYKVWV RLSSQVPSMF FGGTDLAADY YVVSPPTAVS VYTKTPYGRL LADTRTSGFR
+    // We remove all the number, all the spaces, etc
+    newMF = `H${convertAA1To3(newMF.replaceAll(/[^A-Z]/g, ''))}OH`;
+  }
+
+  return newMF;
+}
+
+function convertAA1To3(mf) {
+  let newmf = '';
+  for (let i = 0; i < mf.length; i++) {
+    newmf += aa1To3(mf.charAt(i));
+  }
+  return newmf;
+}
+
+function aa1To3(code) {
+  for (let i = 0; i < aminoAcids.length; i++) {
+    if (aminoAcids[i].aa1 === code) {
+      return aminoAcids[i].aa3;
+    }
+  }
+  throw new Error(`Invalid 1 letter code: ${code}`);
+}
+
+// mf can contain as well parenthesis. We need to check if it is not yet a correct molecular formula
+function isOneLetterCode(mf) {
+  let parenthesisLevel = 0;
+  for (let char of mf) {
+    if (parenthesisLevel === 0 && char.match(/[a-z]/)) return false;
+    if (char === '(') parenthesisLevel++;
+    if (char === ')') parenthesisLevel--;
+  }
+  return true;
+}

package/src/splitPeptide.js

@@ -0,0 +1,13 @@
+export function splitPeptide(sequence) {
+  let aas = sequence.replaceAll(/([A-Z])/g, ' $1').split(/ /);
+  let begin = 0;
+  while (aas[begin] === '' || aas[begin] === 'H') {
+    begin++;
+  }
+  let end = aas.length - 1;
+  while (aas[end] === 'O' || aas[end] === 'H') {
+    end--;
+  }
+  aas = aas.slice(begin, end + 1);
+  return aas;
+}