@datagrok/peptides 0.0.1 → 0.2.0

package/src/utils/cell-renderer.ts

@@ -1,5 +1,6 @@
 import {ChemPalette} from './chem-palette';
 import * as DG from 'datagrok-api/dg';
+
 const cp = new ChemPalette('grok');
 
 export function expandColumn(col:DG.Column,
@@ -22,35 +23,24 @@ export function expandColumn(col:DG.Column,
   timeout);
 }
 
-export function setAARRenderer(
-  col:DG.Column,
-  grid:DG.Grid|null = null,
-) {
+export function setAARRenderer(col:DG.Column, grid:DG.Grid|null = null) {
   col.semType = 'aminoAcids';
   col.setTag('cell.renderer', 'aminoAcids');
-  if (grid) {
-    expandColumn(col, grid, (ent) => measureAAR(ent, true));
-  }
+  if (grid)
+    expandColumn(col, grid, (ent) => measureAAR(ent));
 }
 
-export function measureAAR(s:string,
-  hideMod = false):number {
+export function measureAAR(s: string): number {
   const end = s.lastIndexOf(')');
   const beg = s.indexOf('(');
   return end == beg ? s.length:s.length - (end-beg)+1;
 }
+
 function printLeftCentered(
-  x: number,
-  y: number,
-  w: number,
-  h: number,
-  g: CanvasRenderingContext2D,
-  s: string,
-  color = ChemPalette.undefinedColor,
-  pivot: number = 0,
-  left = false,
-  hideMod = false,
-) {
+      x: number, y: number, w: number, h: number,
+      g: CanvasRenderingContext2D, s: string, color = ChemPalette.undefinedColor,
+      pivot: number = 0, left = false, hideMod = false) {
+
   g.textAlign = 'start';
   let colorPart = pivot == -1 ? s.substring(0) : s.substring(0, pivot);
   if (colorPart.length == 1) {
@@ -60,7 +50,7 @@ function printLeftCentered(
     if (colorPart.substring(0, 3) in ChemPalette.AAFullNames) {
       colorPart = ChemPalette.AAFullNames[s.substring(0, 3)] + colorPart.substr(3);
     } else if (colorPart.substring(1, 4) in ChemPalette.AAFullNames) {
-      colorPart = colorPart.at(0) + ChemPalette.AAFullNames[s.substring(1, 4)] + colorPart.substr(4);
+      colorPart = colorPart[0] + ChemPalette.AAFullNames[s.substring(1, 4)] + colorPart.substr(4);
     }
   }
   let grayPart = pivot == -1 ? '' : s.substr(pivot);
@@ -80,66 +70,48 @@ function printLeftCentered(
   const textSize = g.measureText(colorPart + grayPart);
   const indent = 5;
 
-
   const colorTextSize = g.measureText(colorPart);
-  if (left || textSize.width > w) {
+
+  function draw(dx1: number, dx2: number) {
     g.fillStyle = color;
     g.fillText(
       colorPart,
-      x + indent,
+      x + dx1,
       y + (textSize.fontBoundingBoxAscent + textSize.fontBoundingBoxDescent) / 2,
     );
     g.fillStyle = ChemPalette.undefinedColor;
     g.fillText(
       grayPart,
-      x + indent + colorTextSize.width,
+      x + dx2,
       y + (textSize.fontBoundingBoxAscent + textSize.fontBoundingBoxDescent) / 2,
     );
+  }
+
+
+  if (left || textSize.width > w) {
+    draw(indent, indent + colorTextSize.width);
     return x + colorTextSize.width + g.measureText(grayPart).width;
-  } else {
-    g.fillStyle = color;
-    g.fillText(
-      colorPart,
-      x + (w - textSize.width) / 2,
-      y + (textSize.fontBoundingBoxAscent + textSize.fontBoundingBoxDescent) / 2,
-    );
-    g.fillStyle = ChemPalette.undefinedColor;
-    g.fillText(
-      grayPart,
-      x + (w - textSize.width) / 2 + colorTextSize.width,
-      y + (textSize.fontBoundingBoxAscent + textSize.fontBoundingBoxDescent) / 2,
-    );
+  }
+  else {
+    draw((w - textSize.width) / 2, (w - textSize.width) / 2 + colorTextSize.width);
     return x + (w - textSize.width) / 2 + colorTextSize.width;
   }
 }
 
-export class AminoAcidsCellRenderer extends DG.GridCellRenderer {
-    private fontSize = 15;
-
 
-    get name() {
-      return 'aminoAcidsCR';
-    }
+export class AminoAcidsCellRenderer extends DG.GridCellRenderer {
 
-    get cellType() {
-      return 'aminoAcids';
-    }
+    get name() { return 'aminoAcidsCR'; }
 
+    get cellType() { return 'aminoAcids'; }
 
-    render(
-      g: CanvasRenderingContext2D,
-      x: number,
-      y: number,
-      w: number,
-      h: number,
-      gridCell: DG.GridCell,
-      cellStyle: DG.GridCellStyle,
-    ) {
+    render(g: CanvasRenderingContext2D, x: number, y: number, w: number, h: number,
+           gridCell: DG.GridCell, cellStyle: DG.GridCellStyle) {
       g.save();
       g.beginPath();
       g.rect(x, y, w, h);
       g.clip();
-      g.font = `${this.fontSize}px monospace`;
+      g.font = `14px monospace`;
       g.textBaseline = 'top';
       const s: string = gridCell.cell.value ? gridCell.cell.value : '-';
       const [color, pivot] = cp.getColorPivot(s);
@@ -148,46 +120,29 @@ export class AminoAcidsCellRenderer extends DG.GridCellRenderer {
     }
 }
 
-export class AlignedSequenceCellRenderer extends DG.GridCellRenderer {
-    private maxCellWidth = 200;
 
+export class AlignedSequenceCellRenderer extends DG.GridCellRenderer {
 
-    constructor() {
-      super();
-    }
-
-
-    get name() {
-      return 'alignedSequenceCR';
-    }
-
-    get cellType() {
-      return 'alignedSequence';
-    }
+    get name() { return 'alignedSequenceCR'; }
 
+    get cellType() { return 'alignedSequence'; }
 
-    render(
-      g: CanvasRenderingContext2D,
-      x: number,
-      y: number,
-      w: number,
-      h: number,
-      gridCell: DG.GridCell,
-      cellStyle: DG.GridCellStyle,
-    ) {
-      w = Math.min(gridCell.grid.canvas.width-x, w);
+    render(g: CanvasRenderingContext2D, x: number, y: number, w: number, h: number,
+           gridCell: DG.GridCell, cellStyle: DG.GridCellStyle ) {
+      w = Math.min(gridCell.grid.canvas.width - x, w);
       g.save();
       g.beginPath();
       g.rect(x, y, w, h);
       g.clip();
-      g.font = '15px monospace';
+      g.font = '14px monospace';
       g.textBaseline = 'top';
-      const s: string = gridCell.cell.value;
+      const s: string = gridCell.cell.value ?? '';
 
       const subParts = s.split('-');
       const [text, simplified] = processSequence(subParts);
       const textSize = g.measureText(text.join(''));
-      x = Math.max(x, x+(w-textSize.width)/2);
+      x = Math.max(x, x + (w - textSize.width) / 2);
+
       subParts.forEach((amino: string, index) => {
         const [color, pivot] = cp.getColorPivot(amino);
         g.fillStyle = ChemPalette.undefinedColor;
@@ -197,15 +152,19 @@ export class AlignedSequenceCellRenderer extends DG.GridCellRenderer {
         }
         x = printLeftCentered(x, y, w, h, g, amino, color, pivot, true);
       });
+
       g.restore();
     }
 }
+
+
 export function processSequence(subParts:string[]) : [string[], boolean] {
-  const simplified = !subParts.some((amino, index)=>{
-    return amino.length>1 &&
-        index !=0 &&
-        index != subParts.length-1;
-  });
+
+  const simplified = !subParts.some((amino, index) =>
+    amino.length > 1 &&
+    index != 0 &&
+    index != subParts.length - 1);
+
   const text:string[] = [];
   subParts.forEach((amino: string, index) => {
     if (index < subParts.length) {
@@ -215,5 +174,4 @@ export function processSequence(subParts:string[]) : [string[], boolean] {
     text.push(amino);
   });
   return [text, simplified];
-}
-
+}

package/src/utils/chem-palette.ts

@@ -1,8 +1,11 @@
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
+
+
 export class ChemPalette {
-    cp:{ [Key: string]: string; } = {};
+    cp: {[key: string]: string} = {};
+
     constructor(scheme: string) {
       if (scheme == 'grok') {
         this.cp = ChemPalette.getDatagrok();
@@ -32,32 +35,36 @@ export class ChemPalette {
       const [color, _] = this.getColorPivot(c);
       return color;
     }
+
     getColorAAPivot(c = ''): [string, string, number] {
-      if (c.length == 1 || c.at(1) == '(') {
-        const amino = c.at(0)?.toUpperCase()!;
+      if (c.length == 1 || c[1] == '(') {
+        const amino = c[0]?.toUpperCase()!;
         return amino in this.cp?
           [this.cp[amino], amino, 1]:
           [ChemPalette.undefinedColor, '', 1];
       }
-      if (c.at(0) == 'd' && c.at(1)! in this.cp) {
-        if (c.length == 2 || c.at(2) == '(') {
-          const amino = c.at(1)?.toUpperCase()!;
+
+      if (c[0] == 'd' && c[1]! in this.cp) {
+        if (c.length == 2 || c[2] == '(') {
+          const amino = c[1]?.toUpperCase()!;
           return amino in this.cp?
             [this.cp[amino], amino, 2]:
             [ChemPalette.undefinedColor, '', 2];
         }
       }
+
       if (c.substr(0, 3) in ChemPalette.AAFullNames) {
-        if (c.length == 3 || c.at(3) == '(') {
+        if (c.length == 3 || c[3] == '(') {
           const amino = ChemPalette.AAFullNames[c.substr(0, 3)];
           return amino in this.cp?
             [this.cp[amino], amino, 3]:
             [ChemPalette.undefinedColor, '', 3];
         }
       }
-      if (c.at(0)?.toLowerCase() == c.at(0)) {
+
+      if (c[0]?.toLowerCase() == c[0]) {
         if (c.substr(1, 3) in ChemPalette.AAFullNames) {
-          if (c.length == 4 || c.at(4) == '(') {
+          if (c.length == 4 || c[4] == '(') {
             const amino = ChemPalette.AAFullNames[c.substr(1, 3)];
             return amino in this.cp?
               [this.cp[amino], amino, 4]:
@@ -65,16 +72,17 @@ export class ChemPalette {
           }
         }
       }
+
       return [ChemPalette.undefinedColor, '', 0];
-      //return c ? DG.Color.toRgb(this.colorScale(c)) : 'rgb(127,127,127)'
     }
+
     getColorPivot(c = ''): [string, number] {
       // eslint-disable-next-line no-unused-vars
       const [color, _, pivot] = this.getColorAAPivot(c);
       return [color, pivot];
     };
 
-    static colourPalette: { [key: string]: string[] } = {
+    static colourPalette: {[key: string]: string[]} = {
       'orange': ['rgb(255,187,120)', 'rgb(245,167,100)', 'rgb(235,137,70)', 'rgb(205, 111, 71)'],
       'all_green': ['rgb(44,160,44)', 'rgb(74,160,74)', 'rgb(23,103,57)', 'rgb(30,110,96)', 'rgb(60,131,95)',
         'rgb(24,110,79)', 'rgb(152,223,138)', 'rgb(182, 223, 138)', 'rgb(152, 193, 138)'],
@@ -97,29 +105,44 @@ export class ChemPalette {
       'white': ['rgb(230,230,230)'],
     }
 
-    static grokGroups: [string[], string][] = [
-      [['C', 'U'], 'yellow'],
-      [['G', 'P'], 'red'],
-      [['A', 'V', 'I', 'L', 'M', 'F', 'Y', 'W'], 'all_green'],
-      [['R', 'H', 'K'], 'light_blue'],
-      [['D', 'E'], 'dark_blue'],
-      [['S', 'T', 'N', 'Q'], 'orange'],
-    ];
+    // static grokGroups: [string[], string][] = [
+    //   [['C', 'U'], 'yellow'],
+    //   [['G', 'P'], 'red'],
+    //   [['A', 'V', 'I', 'L', 'M', 'F', 'Y', 'W'], 'all_green'],
+    //   [['R', 'H', 'K'], 'light_blue'],
+    //   [['D', 'E'], 'dark_blue'],
+    //   [['S', 'T', 'N', 'Q'], 'orange'],
+    // ];
+    static grokGroups: {[key: string]: string[]} = {
+      'yellow': ['C', 'U'],
+      'red': ['G', 'P'],
+      'all_green': ['A', 'V', 'I', 'L', 'M', 'F', 'Y', 'W'],
+      'light_blue': ['R', 'H', 'K'],
+      'dark_blue': ['D', 'E'],
+      'orange': ['S', 'T', 'N', 'Q'],
+    }
+
+    static leskGroups: {[key: string]: string[]} = {
+      'orange': ['G', 'A', 'S', 'T'],
+      'all_green': ['C', 'V', 'I', 'L', 'P', 'F', 'Y', 'M', 'W'],
+      'magenta': ['N', 'Q', 'H'],
+      'red': ['D', 'E'],
+      'all_blue': ['K', 'R'],
+    }
+
     static undefinedColor = 'rgb(100,100,100)'
 
-    static makePalette(dt: [string[], string][], simplified = false) {
+    static makePalette(dt: {[key: string]: string[]}, simplified = false) {
       const palette: { [key: string]: string } = {};
-      dt.forEach((cp) => {
-        const objList = cp[0];
-        const colour = cp[1];
-        objList.forEach((obj, ind) => {
-          palette[obj] = ChemPalette.colourPalette[colour][simplified ? 0 : ind];
+      for (const [color, monomers] of Object.entries(dt)) {
+        monomers.forEach((monomer, index) => {
+          palette[monomer] = ChemPalette.colourPalette[color][simplified ? 0 : index];
         });
-      });
+      }
       return palette;
     }
 
-    static AANames:{ [Key: string]: string; } = {
+    static AANames: {[key: string]: string} = {
       'G': 'Glycine',
       'L': 'Leucine',
       'Y': 'Tyrosine',
@@ -141,7 +164,8 @@ export class ChemPalette {
       'M': 'Methionine',
       'T': 'Threonine',
     }
-    static AASmiles: { [Key: string]: string; } = {
+
+    static AASmiles: {[key: string]: string} = {
       'G': 'NCC(=O)O',
       'L': 'N[C@H](CC(C)C)C(=O)O',
       'Y': 'NC(CC1=CC=C(O)C=C1)C(=O)O',
@@ -153,7 +177,7 @@ export class ChemPalette {
       'F': 'NC(CC1=CC=CC=C1)C(=O)O',
       'A': 'N[C@H](C)C(=O)O',
       'K': 'NC(CCCCN)C(=O)O',
-      'R': 'N[C(=O)OH](CCCNC(N)=N)C(=O)O',
+      'R': 'N[C@H](CCCNC(=N)C)C(=O)O',
       'H': 'NC(CC1=CN=C[N]1)C(=O)O',
       'C': 'N[C@@H](CS)C(=O)O',
       'V': 'NC(C(C)C)C(=O)O',
@@ -163,7 +187,8 @@ export class ChemPalette {
       'M': 'NC(CCSC)C(=O)O',
       'T': 'NC(C(O)C)C(=O)O',
     }
-    static AASmilesTruncated: { [Key: string]: string; } = {
+
+    static AASmilesTruncated: {[key: string]: string} = {
       'G': '*C*',
       'L': 'CC(C)C[C@H](*)*',
       'Y': 'C1=CC(=CC=C1CC(*)*)O',
@@ -175,7 +200,7 @@ export class ChemPalette {
       'F': 'C1=CC=C(C=C1)CC(*)*',
       'A': 'C[C@H](*)*',
       'K': 'C(CCN)CC(*)*',
-      'R': '*[C(=O)OH](CCCNC(N)=N)*',
+      'R': '*[C@H](CCCNC(=N)C)*',
       'H': 'C1=C(NC=N1)CC(*)*',
       'C': 'C([C@@H](*)*)S',
       'V': 'CC(C)C(*)*',
@@ -186,7 +211,7 @@ export class ChemPalette {
       'T': 'CC(O)C(*)*',
     }
 
-    static AAFullNames: { [Key: string]: string; } = {
+    static AAFullNames: {[key: string]: string} = {
       'Ala': 'A',
       'Arg': 'R',
       'Asn': 'N',
@@ -207,16 +232,13 @@ export class ChemPalette {
       'Trp': 'W',
       'Tyr': 'Y',
       'Val': 'V',
-    };
+    }
 
-    static getDatagrok = ():{ [Key: string]: string; } => {
+    static getDatagrok() {
       return ChemPalette.makePalette(ChemPalette.grokGroups);
-    };
+    }
 
-    getLesk = () => ChemPalette.makePalette([
-      [['G', 'A', 'S', 'T'], 'orange'],
-      [['C', 'V', 'I', 'L', 'P', 'F', 'Y', 'M', 'W'], 'all_green'],
-      [['N', 'Q', 'H'], 'magenta'],
-      [['D', 'E'], 'red'],
-      [['K', 'R'], 'all_blue']])
+    static getLesk() {
+      return ChemPalette.makePalette(ChemPalette.leskGroups);
+    }
 }

package/src/utils/molecular-measure.ts

@@ -0,0 +1,175 @@
+/**
+ * Library of molecular weights.
+ * @link https://worldwide.promega.com/resources/tools/amino-acid-chart-amino-acid-structure */
+const _lib = [
+  {
+    'Name': 'Alanine',
+    'Three-letter': 'Ala',
+    'One-letter': 'A',
+    'Weight': '89Da',
+  },
+  {
+    'Name': 'Arginine',
+    'Three-letter': 'Arg',
+    'One-letter': 'R',
+    'Weight': '174Da',
+  },
+  {
+    'Name': 'Asparagine',
+    'Three-letter': 'Asn',
+    'One-letter': 'N',
+    'Weight': '132Da',
+  },
+  {
+    'Name': 'Aspartic acid',
+    'Three-letter': 'Asp',
+    'One-letter': 'D',
+    'Weight': '133Da',
+  },
+  {
+    'Name': 'Asparagine or aspartic acid',
+    'Three-letter': 'Asx',
+    'One-letter': 'B',
+    'Weight': '133Da',
+  },
+  {
+    'Name': 'Cysteine',
+    'Three-letter': 'Cys',
+    'One-letter': 'C',
+    'Weight': '121Da',
+  },
+  {
+    'Name': 'Glutamine',
+    'Three-letter': 'Gln',
+    'One-letter': 'Q',
+    'Weight': '146Da',
+  },
+  {
+    'Name': 'Glutamic acid',
+    'Three-letter': 'Glu',
+    'One-letter': 'E',
+    'Weight': '147Da',
+  },
+  {
+    'Name': 'Glutamine or glutamic acid',
+    'Three-letter': 'Glx',
+    'One-letter': 'Z',
+    'Weight': '147Da',
+  },
+  {
+    'Name': 'Glycine',
+    'Three-letter': 'Gly',
+    'One-letter': 'G',
+    'Weight': '75Da',
+  },
+  {
+    'Name': 'Histidine',
+    'Three-letter': 'His',
+    'One-letter': 'H',
+    'Weight': '155Da',
+  },
+  {
+    'Name': 'Isoleucine',
+    'Three-letter': 'Ile',
+    'One-letter': 'I',
+    'Weight': '131Da',
+  },
+  {
+    'Name': 'Leucine',
+    'Three-letter': 'Leu',
+    'One-letter': 'L',
+    'Weight': '131Da',
+  },
+  {
+    'Name': 'Lysine',
+    'Three-letter': 'Lys',
+    'One-letter': 'K',
+    'Weight': '146Da',
+  },
+  {
+    'Name': 'Methionine',
+    'Three-letter': 'Met',
+    'One-letter': 'M',
+    'Weight': '149Da',
+  },
+  {
+    'Name': 'Phenylalanine',
+    'Three-letter': 'Phe',
+    'One-letter': 'F',
+    'Weight': '165Da',
+  },
+  {
+    'Name': 'Proline',
+    'Three-letter': 'Pro',
+    'One-letter': 'P',
+    'Weight': '115Da',
+  },
+  {
+    'Name': 'Serine',
+    'Three-letter': 'Ser',
+    'One-letter': 'S',
+    'Weight': '105Da',
+  },
+  {
+    'Name': 'Threonine',
+    'Three-letter': 'Thr',
+    'One-letter': 'T',
+    'Weight': '119Da',
+  },
+  {
+    'Name': 'Tryptophan',
+    'Three-letter': 'Trp',
+    'One-letter': 'W',
+    'Weight': '204Da',
+  },
+  {
+    'Name': 'Tyrosine',
+    'Three-letter': 'Tyr',
+    'One-letter': 'Y',
+    'Weight': '181Da',
+  },
+  {
+    'Name': 'Valine',
+    'Three-letter': 'Val',
+    'One-letter': 'V',
+    'Weight': '117Da',
+  },
+];
+
+/**
+ * Selection of the molecular weights of amino acid residues.
+ * @type {*} */
+const weightsLib : {[name: string]: number} = {};
+
+// Create a dictionary linking one-letter code with the corresponding residues weight.
+for (const d of _lib) {
+  weightsLib[d['One-letter']] = parseFloat(d.Weight.substring(0, d.Weight.length-2));
+}
+
+/**
+ * Calculates molecular weight of the given peptide in daltons.
+ *
+ * @export
+ * @param {string} sequence Peptide sequence.
+ * @return {number} Molecular weight in Da.
+ */
+export function getSequenceMolecularWeight(sequence: string): number {
+  let sum = 0;
+
+  if (sequence.startsWith('NH2')) {
+    sum += 16.02;
+    sequence = sequence.substring(3);
+  }
+
+  if (sequence.endsWith('COOH')) {
+    sum += 45.02;
+    sequence = sequence.substring(0, sequence.length-4);
+  }
+
+  for (const i of sequence) {
+    if (i in weightsLib) {
+      sum += weightsLib[i];
+    }
+  }
+  return sum;
+}