@datagrok/peptides 0.8.9 → 0.8.13

package/src/utils/SAR-multiple-selection.ts

@@ -0,0 +1,177 @@
+import * as DG from 'datagrok-api/dg';
+
+import {StringDictionary} from '@datagrok-libraries/utils/src/type-declarations';
+
+type Operation = (op1: boolean, op2: boolean) => boolean;
+
+/** Logical operations awailable between selection items. */
+const Operations: {[op: string]: Operation} = {
+  and: (op1: boolean, op2: boolean) => op1 && op2,
+  or: (op1: boolean, op2: boolean) => op1 || op2,
+};
+
+type FilterOperation = 'and' | 'or';
+type PositionFilter = {[pos: string]: Set<string>};
+
+/** Implements multiple selection in position-residue space. */
+export class MultipleSelection {
+  conjunction: boolean;
+  filter: PositionFilter;
+  protected operation: Operation;
+  protected complete: (v: boolean) => boolean;
+
+  /**
+   * Creates an instance of MultipleSelection.
+   * @param {FilterOperation} [operation='and'] Operation to apply to items.
+   */
+  constructor(operation: FilterOperation = 'and') {
+    this.conjunction = operation == 'and';
+    this.filter = {};
+    this.operation = Operations[operation];
+    this.complete = (v: boolean) => (this.conjunction && !v) || (!this.conjunction && v);
+  }
+
+  /**
+   * Adds position-residue entity into selection.
+   * @param {string} pos Position in a sequence.
+   * @param {string} res Residue at the position.
+   */
+  input(pos: string, res: string) {
+    if (!this.filter[pos])
+      this.filter[pos] = new Set([]);
+
+    if (this.filter[pos].has(res))
+      this.remove(pos, res);
+    else
+      this.filter[pos].add(res);
+  }
+
+  /**
+   * Removes position-residue entity from selection.
+   * @param {string} pos Position in a sequence.
+   * @param {string} res Residue at the position.
+   */
+  remove(pos: string, res: string) {
+    if (this.filter[pos]) {
+      this.filter[pos].delete(res);
+
+      if (this.filter[pos].size == 0)
+        delete this.filter[pos];
+    }
+  }
+
+  /**
+   * Sets the particular residue at position into selection.
+   * @param {string} pos Position in a sequence.
+   * @param {string} res Residue at the position.
+   */
+  set(pos: string, res: string) {
+    for (const p of Object.keys(this.filter))
+      delete this.filter[p];
+
+    this.filter[pos] = new Set([res]);
+  }
+
+  /**
+   * Sets the particular position with the given residues into selection.
+   * @param {string} pos Position in a sequence.
+   * @param {string[]} values Residues list at the position.
+   */
+  setPos(pos: string, values: string[]) {
+    this.filter[pos] = new Set(values);
+  }
+
+  /**
+   * Sets the particular residue to be at given positions into selection.
+   * @param {string} res Residue to set.
+   * @param {string[]} values Positions list to assign the residue to.
+   */
+  setRes(res: string, values: string[]) {
+    for (const pos of values) {
+      if (this.filter[pos])
+        this.filter[pos].add(res);
+      else
+        this.filter[pos] = new Set([res]);
+    }
+  }
+
+  /**
+   * Evaluates selection into a list of booleans of the same length as the given data frame.
+   * @param {DG.DataFrame} df Data frame to consider.
+   * @param {StringDictionary} [mapper={}] Optional residues mapper.
+   * @return {boolean[]} List of trues/falses corresponding selection constructed.
+   */
+  eval(df: DG.DataFrame, mapper: StringDictionary = {}): boolean[] {
+    const itemsCount = df.rowCount;
+    const cond = new Array<boolean>(itemsCount).fill(this.conjunction);
+
+    for (let i = 0; i < itemsCount; ++i)
+      cond[i] = this.match(i, df, mapper);
+
+    return cond;
+  }
+
+  /**
+   * Tests if i-th element matches filter.
+   * @param {number} i Element's index
+   * @param {DG.DataFrame} df Data frame to consider.
+   * @param {StringDictionary} [mapper={}] Optional residues mapper.
+   * @return {boolean} Result of the test.
+   */
+  match(i: number, df: DG.DataFrame, mapper: StringDictionary = {}): boolean {
+    let cond: boolean = this.conjunction;
+
+    for (const [posColumnName, resFilter] of Object.entries(this.filter)) {
+      const residue = df.get(posColumnName, i);
+      const isMatched = resFilter.has(mapper[residue] ?? residue);
+      cond = this.operation(cond, isMatched);
+
+      if (this.complete(cond))
+        break;
+    }
+    return cond;
+  }
+
+  /**
+   * Tests if position-residue is selected.
+   * @param {string} pos Position in a sequence.
+   * @param {string} res Residue at the position.
+   * @param {StringDictionary} [mapper={}] Optional residues mapper.
+   * @return {boolean} True if this entity is selected else false.
+   */
+  test(pos: string, res: string, mapper: StringDictionary = {}): boolean {
+    if (this.filter[pos])
+      return this.filter[pos].has(mapper[res] ?? res);
+
+    return false;
+  }
+
+  /**
+   * Make string representation of the selected items.
+   * @return {string} String representation.
+   */
+  toString(): string {
+    let repr = '';
+
+    for (const [pos, res] of Object.entries(this.filter))
+      repr += `${pos}: ${Array.from(res).join(',')}\n`;
+
+    return repr;
+  }
+
+  /**
+   * Turns filter into grouping query string.
+   * @param {string} [residueColumnName='Res'] Optional residues column name.
+   * @return {string} Query-formatted string.
+   */
+  toQuery(residueColumnName: string = 'Res'): string {
+    const alt: string[] = [];
+
+    for (const [pos, residues] of Object.entries(this.filter)) {
+      for (const res of residues)
+        alt.push(`${residueColumnName} = ${res} and Pos = ${pos}`);
+    }
+
+    return alt.join(' or ');
+  }
+}

package/src/utils/cell-renderer.ts

@@ -1,7 +1,7 @@
 import {ChemPalette} from './chem-palette';
 import * as DG from 'datagrok-api/dg';
 
-const cp = new ChemPalette('grok');
+import * as C from './constants';
 
 /**
  * A function to expand column size based on its contents.
@@ -40,8 +40,8 @@ export function expandColumn(
  * @param {boolean} [grouping=false] Is grouping enabled.
  */
 export function setAARRenderer(col: DG.Column, grid: DG.Grid | null = null, grouping = false) {
-  col.semType = 'aminoAcids';
-  col.setTag('cell.renderer', 'aminoAcids');
+  col.semType = C.SEM_TYPES.AMINO_ACIDS;
+  col.setTag('cell.renderer', C.SEM_TYPES.AMINO_ACIDS);
   if (grouping)
     col.setTag('groups', `${grouping}`);
 
@@ -89,42 +89,35 @@ function printLeftOrCentered(
 
   if (colorPart.length >= 3) {
     if (colorPart.substring(0, 3) in ChemPalette.AAFullNames)
-      colorPart = ChemPalette.AAFullNames[s.substring(0, 3)] + colorPart.substr(3);
+      colorPart = ChemPalette.AAFullNames[s.substring(0, 3)] + colorPart.substring(3);
     else if (colorPart.substring(1, 4) in ChemPalette.AAFullNames)
-      colorPart = colorPart[0] + ChemPalette.AAFullNames[s.substring(1, 4)] + colorPart.substr(4);
+      colorPart = colorPart[0] + ChemPalette.AAFullNames[s.substring(1, 4)] + colorPart.substring(4);
   }
-  let grayPart = pivot == -1 ? '' : s.substr(pivot);
+  let grayPart = pivot == -1 ? '' : s.substring(pivot);
   if (hideMod) {
     let end = colorPart.lastIndexOf(')');
     let beg = colorPart.indexOf('(');
     if (beg > -1 && end > -1 && end - beg > 2)
-      colorPart = colorPart.substr(0, beg) + '(+)' + colorPart.substr(end + 1);
+      colorPart = colorPart.substring(0, beg) + '(+)' + colorPart.substring(end + 1);
 
 
     end = grayPart.lastIndexOf(')');
     beg = grayPart.indexOf('(');
     if (beg > -1 && end > -1 && end - beg > 2)
-      grayPart = grayPart.substr(0, beg) + '(+)' + grayPart.substr(end + 1);
+      grayPart = grayPart.substring(0, beg) + '(+)' + grayPart.substring(end + 1);
   }
   const textSize = g.measureText(colorPart + grayPart);
   const indent = 5;
 
   const colorTextSize = g.measureText(colorPart);
+  const dy = (textSize.fontBoundingBoxAscent + textSize.fontBoundingBoxDescent) / 2;
 
   function draw(dx1: number, dx2: number) {
     g.fillStyle = color;
     g.globalAlpha = transparencyRate;
-    g.fillText(
-      colorPart,
-      x + dx1,
-      y + (textSize.fontBoundingBoxAscent + textSize.fontBoundingBoxDescent) / 2,
-    );
+    g.fillText(colorPart, x + dx1, y + dy);
     g.fillStyle = ChemPalette.undefinedColor;
-    g.fillText(
-      grayPart,
-      x + dx2,
-      y + (textSize.fontBoundingBoxAscent + textSize.fontBoundingBoxDescent) / 2,
-    );
+    g.fillText(grayPart, x + dx2, y + dy);
   }
 
 
@@ -132,8 +125,9 @@ function printLeftOrCentered(
     draw(indent, indent + colorTextSize.width);
     return x + colorTextSize.width + g.measureText(grayPart).width;
   } else {
-    draw((w - textSize.width) / 2, (w - textSize.width) / 2 + colorTextSize.width);
-    return x + (w - textSize.width) / 2 + colorTextSize.width;
+    const dx = (w - textSize.width) / 2;
+    draw(dx, dx + colorTextSize.width);
+    return x + dx + colorTextSize.width;
   }
 }
 
@@ -164,7 +158,7 @@ export class AminoAcidsCellRenderer extends DG.GridCellRenderer {
      * @memberof AminoAcidsCellRenderer
      */
   get cellType() {
-    return 'aminoAcids';
+    return C.SEM_TYPES.AMINO_ACIDS;
   }
 
   /**
@@ -209,7 +203,7 @@ export class AminoAcidsCellRenderer extends DG.GridCellRenderer {
   render(
     g: CanvasRenderingContext2D, x: number, y: number, w: number, h: number, gridCell: DG.GridCell,
     cellStyle: DG.GridCellStyle) {
-    this.chemPalette ??= new ChemPalette('grok', gridCell.tableColumn?.getTag('groups') ? true : false);
+    // this.chemPalette ??= new ChemPalette('grok', gridCell.tableColumn?.getTag('groups') ? true : false);
 
     y -= 2;
     g.save();
@@ -219,7 +213,7 @@ export class AminoAcidsCellRenderer extends DG.GridCellRenderer {
     g.font = `12px monospace`;
     g.textBaseline = 'top';
     const s: string = gridCell.cell.value ? gridCell.cell.value : '-';
-    let [color, outerS, innerS, pivot] = cp.getColorAAPivot(s);
+    let [color, outerS, innerS, pivot] = ChemPalette.getColorAAPivot(s);
     if (innerS)
       outerS = s;
 
@@ -253,7 +247,7 @@ export class AlignedSequenceCellRenderer extends DG.GridCellRenderer {
    * @memberof AlignedSequenceCellRenderer
    */
   get cellType() {
-    return 'alignedSequence';
+    return C.SEM_TYPES.ALIGNED_SEQUENCE;
   }
 
   /**
@@ -289,10 +283,10 @@ export class AlignedSequenceCellRenderer extends DG.GridCellRenderer {
    * @memberof AlignedSequenceCellRenderer
    */
   render(
-    g: CanvasRenderingContext2D, x: number, y: number, w: number, h: number,
-    gridCell: DG.GridCell, cellStyle: DG.GridCellStyle,
+    g: CanvasRenderingContext2D, x: number, y: number, w: number, h: number, gridCell: DG.GridCell,
+    cellStyle: DG.GridCellStyle,
   ) {
-    const grid = gridCell.dart.grid ? gridCell.grid : gridCell.dart.grid;
+    const grid = gridCell.grid;
     const cell = gridCell.cell;
     w = grid ? Math.min(grid.canvas.width - x, w) : g.canvas.width - x;
     g.save();
@@ -307,16 +301,16 @@ export class AlignedSequenceCellRenderer extends DG.GridCellRenderer {
     const subParts = s.split('-');
     const [text, simplified] = processSequence(subParts);
     const textSize = g.measureText(text.join(''));
-    x = Math.max(x, x + (w - textSize.width) / 2);
+    let x1 = Math.max(x, x + (w - textSize.width) / 2);
 
-    subParts.forEach((amino: string, index) => {
-      let [color, outerAmino,, pivot] = cp.getColorAAPivot(amino);
+    subParts.forEach((amino, index) => {
+      let [color, outerAmino,, pivot] = ChemPalette.getColorAAPivot(amino);
       g.fillStyle = ChemPalette.undefinedColor;
       if (index + 1 < subParts.length) {
         const gap = simplified ? '' : ' ';
-        outerAmino += `${outerAmino?'':'-'}${gap}`;
+        outerAmino += `${outerAmino ? '' : '-'}${gap}`;
       }
-      x = printLeftOrCentered(x, y, w, h, g, outerAmino, color, pivot, true);
+      x1 = printLeftOrCentered(x1, y, w, h, g, outerAmino, color, pivot, true);
     });
 
     g.restore();
@@ -408,10 +402,9 @@ export class AlignedSequenceDifferenceCellRenderer extends DG.GridCellRenderer {
    * @memberof AlignedSequenceDifferenceCellRenderer
    */
   render(
-    g: CanvasRenderingContext2D, x: number, y: number, w: number, h: number,
-    gridCell: DG.GridCell, cellStyle: DG.GridCellStyle,
-  ) {
-    const grid = gridCell.dart.grid ? gridCell.grid : gridCell.dart.grid;
+    g: CanvasRenderingContext2D, x: number, y: number, w: number, h: number, gridCell: DG.GridCell,
+    cellStyle: DG.GridCellStyle) {
+    const grid = gridCell.grid;
     const cell = gridCell.cell;
 
     w = grid ? Math.min(grid.canvas.width - x, w) : g.canvas.width - x;
@@ -429,26 +422,32 @@ export class AlignedSequenceDifferenceCellRenderer extends DG.GridCellRenderer {
     const subParts2 = s2.split('-');
     const [text] = processSequence(subParts1);
     const textSize = g.measureText(text.join(''));
-    x = Math.max(x, x + (w - textSize.width) / 2);
+    let updatedX = Math.max(x, x + (w - (textSize.width + subParts1.length * 4)) / 2);
+    // 28 is the height of the two substitutions on top of each other + space
+    const updatedY = Math.max(y, y + (h - 28) / 2);
 
+    let amino2;
+    let updatedAmino1: string;
+    let updatedAmino2: string;
     subParts1.forEach((amino1: string, index) => {
-      let amino2 = subParts2[index];
-      const [color1, amino1Outer, amino1Inner, pivot1] = cp.getColorAAPivot(amino1);
-      const [color2, amino2Outer, amino2Inner, pivot2] = cp.getColorAAPivot(amino2);
+      amino2 = subParts2[index];
+      const [color1, amino1Outer, amino1Inner, pivot1] = ChemPalette.getColorAAPivot(amino1);
+      const [color2, amino2Outer, amino2Inner, pivot2] = ChemPalette.getColorAAPivot(amino2);
 
-      if (amino1 != amino2) {
-        const verticalShift = 7;
+      updatedAmino1 = amino1Outer + (amino1Inner !== '' ? '(' + amino1Inner + ')' : '');
+      updatedAmino1 = updatedAmino1 === '' ? '-' : updatedAmino1;
 
-        amino1 = amino1Outer + (amino1Inner !== '' ? '(' + amino1Inner + ')' : '');
-        amino2 = amino2Outer + (amino2Inner !== '' ? '(' + amino2Inner + ')' : '');
-        amino1 = amino1 === '' ? '-' : amino1;
-        amino2 = amino2 === '' ? '-' : amino2;
+      if (amino1 != amino2) {
+        updatedAmino2 = amino2Outer + (amino2Inner !== '' ? '(' + amino2Inner + ')' : '');
+        updatedAmino2 = updatedAmino2 === '' ? '-' : updatedAmino2;
 
-        const x1 = printLeftOrCentered(x, y - verticalShift, w, h, g, amino1, color1, pivot1, true);
-        x = printLeftOrCentered(x, y + verticalShift, w, h, g, amino2, color2, pivot2, true);
-        x = Math.max(x, x1) + 4;
+        const vShift = 7;
+        const subX0 = printLeftOrCentered(updatedX, updatedY - vShift, w, h, g, updatedAmino1, color1, pivot1, true);
+        const subX1 = printLeftOrCentered(updatedX, updatedY + vShift, w, h, g, updatedAmino2, color2, pivot2, true);
+        updatedX = Math.max(subX1, subX0);
       } else
-        x = printLeftOrCentered(x, y, w, h, g, amino1 ? amino1 : '-', color1, pivot1, true, true, 0.5) + 4;
+        updatedX = printLeftOrCentered(updatedX, updatedY, w, h, g, updatedAmino1, color1, pivot1, true, true, 0.5);
+      updatedX += 4;
     });
     g.restore();
   }