@datagrok/bio 2.1.11 → 2.4.2

package/src/utils/cell-renderer.ts

@@ -3,11 +3,32 @@ import * as DG from 'datagrok-api/dg';
 import * as ui from 'datagrok-api/ui';
 
 import {printLeftOrCentered, DrawStyle} from '@datagrok-libraries/bio/src/utils/cell-renderer';
-import * as bio from '@datagrok-libraries/bio';
 import * as C from './constants';
+import {
+  ALIGNMENT,
+  getPaletteByType,
+  getSplitter,
+  monomerToShort,
+  NOTATION,
+  SplitterFunc,
+  TAGS as bioTAGS,
+} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {SeqPalette} from '@datagrok-libraries/bio/src/seq-palettes';
+import {UnknownSeqPalettes} from '@datagrok-libraries/bio/src/unknown';
+
+const enum tempTAGS {
+  referenceSequence = 'reference-sequence',
+  currentWord = 'current-word',
+  monomerWidth = 'monomer-width',
+  bioSumMaxLengthWords = 'bio-sum-maxLengthWords',
+  bioMaxIndex = 'bio-maxIndex',
+  bioMaxLengthWords = 'bio-maxLengthWords',
+}
+
+type TempType = { [tagName: string]: any };
 
 const undefinedColor = 'rgb(100,100,100)';
-const monomerToShortFunction: (amino: string, maxLengthOfMonomer: number) => string = bio.monomerToShort;
+const monomerToShortFunction: (amino: string, maxLengthOfMonomer: number) => string = monomerToShort;
 
 function getUpdatedWidth(grid: DG.Grid | null, g: CanvasRenderingContext2D, x: number, w: number): number {
   return grid ? Math.min(grid.canvas.width - x, w) : g.canvas.width - x;
@@ -41,16 +62,18 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
   get defaultWidth(): number { return 230; }
 
   onClick(gridCell: DG.GridCell, e: MouseEvent): void {
-    gridCell.cell.column.temp['current-word'] = gridCell.cell.value;
+    const colTemp: TempType = gridCell.cell.column.temp;
+    colTemp[tempTAGS.currentWord] = gridCell.cell.value;
     gridCell.grid.invalidate();
   }
 
   onMouseMove(gridCell: DG.GridCell, e: MouseEvent): void {
-    if (gridCell.cell.column.getTag(bio.TAGS.aligned) !== bio.ALIGNMENT.SEQ_MSA)
+    if (gridCell.cell.column.getTag(bioTAGS.aligned) !== ALIGNMENT.SEQ_MSA)
       return;
 
-    const maxLengthWordsSum = gridCell.cell.column.temp['bio-sum-maxLengthWords'];
-    const maxIndex = gridCell.cell.column.temp['bio-maxIndex'];
+    const colTemp: TempType = gridCell.cell.column.temp;
+    const maxLengthWordsSum = colTemp[tempTAGS.bioSumMaxLengthWords];
+    const maxIndex = colTemp[tempTAGS.bioMaxIndex];
     const argsX = e.offsetX - gridCell.gridColumn.left + (gridCell.gridColumn.left - gridCell.bounds.x);
     let left = 0;
     let right = maxIndex;
@@ -74,7 +97,7 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
     }
     left = (argsX >= maxLengthWordsSum[left]) ? left + 1 : left;
     const separator = gridCell.cell.column.getTag('separator') ?? '';
-    const splitterFunc: bio.SplitterFunc = bio.getSplitter('separator', separator);
+    const splitterFunc: SplitterFunc = getSplitter('separator', separator);
     const subParts: string[] = splitterFunc(gridCell.cell.value);
     (((subParts[left]?.length ?? 0) > 0)) ?
       ui.tooltip.show(ui.div(subParts[left]), e.x + 16, e.y + 16) : ui.tooltip.hide();
@@ -95,10 +118,10 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
   render(
     g: CanvasRenderingContext2D, x: number, y: number, w: number, h: number, gridCell: DG.GridCell,
     cellStyle: DG.GridCellStyle
-  ): void {
+  ) {
     const grid = gridCell.gridRow !== -1 ? gridCell.grid : null;
     const cell = gridCell.cell;
-    const paletteType = gridCell.cell.column.getTag(C.TAGS.ALPHABET);
+    const paletteType = gridCell.cell.column.getTag(bioTAGS.alphabet);
     const minDistanceRenderer = 50;
     w = getUpdatedWidth(grid, g, x, w);
     g.save();
@@ -110,19 +133,28 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
 
     //TODO: can this be replaced/merged with splitSequence?
     const units = gridCell.cell.column.getTag(DG.TAGS.UNITS);
+    const aligned: string = gridCell.cell.column.getTag(bioTAGS.aligned);
 
-    const palette = bio.getPaletteByType(paletteType);
+    const palette = getPaletteByType(paletteType);
 
-    const separator = gridCell.cell.column.getTag('separator') ?? '';
-    const splitLimit = gridCell.bounds.width / 5;
-    const splitterFunc: bio.SplitterFunc = bio.getSplitter(units, separator, splitLimit);
-    const referenceSequence: string[] = splitterFunc(((gridCell.cell.column?.temp['reference-sequence'] != null) && (gridCell.cell.column?.temp['reference-sequence'] != ''))
-      ? gridCell.cell.column.temp['reference-sequence'] : gridCell.cell.column.temp['current-word'] ?? '');
-    const monomerWidth = (gridCell.cell.column?.temp['monomer-width'] != null) ? gridCell.cell.column.temp['monomer-width'] : 'short';
-    let gapRenderer = 5;
+    const separator = gridCell.cell.column.getTag(bioTAGS.separator) ?? '';
+    const splitLimit = w / 5;
+    const splitterFunc: SplitterFunc = getSplitter(units, separator, splitLimit);
 
-    let maxIndex = 0;
+    // TODO: Store temp data to GridColumn
+    // Now the renderer requires data frame table Column underlying GridColumn
+    const colTemp: TempType = gridCell.cell.column.temp;
+
+    const tempReferenceSequence: string | null = colTemp[tempTAGS.referenceSequence];
+    const tempCurrentWord: string | null = colTemp[tempTAGS.currentWord];
+    const tempMonomerWidth: string | null = colTemp[tempTAGS.monomerWidth];
+    const referenceSequence: string[] = splitterFunc(
+      ((tempReferenceSequence != null) && (tempReferenceSequence != '')) ?
+        tempReferenceSequence : tempCurrentWord ?? '');
+    const monomerWidth: string = (tempMonomerWidth != null) ? tempMonomerWidth : 'short';
 
+    let gapRenderer = 5;
+    let maxIndex = 0;
     let maxLengthOfMonomer = 8;
 
     if (monomerWidth === 'short') {
@@ -140,44 +172,42 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
           const textSize = monomerToShortFunction(amino, maxLengthOfMonomer).length * 7 + gapRenderer;
           if (textSize > (maxLengthWords[index] ?? 0))
             maxLengthWords[index] = textSize;
-          if (index > maxIndex) {
-            maxIndex = index;
-          }
+          if (index > maxIndex) maxIndex = index;
         });
         samples += 1;
       }
-      let minLength = 3 * 7;
+      const minLength = 3 * 7;
       for (let i = 0; i <= maxIndex; i++) {
-        if (maxLengthWords[i] < minLength) {
-          maxLengthWords[i] = minLength;
-        }
+        if (maxLengthWords[i] < minLength) maxLengthWords[i] = minLength;
         const maxLengthWordSum: any = {};
         maxLengthWordSum[0] = maxLengthWords[0];
-        for (let i = 1; i <= maxIndex; i++) {
-          maxLengthWordSum[i] = maxLengthWordSum[i - 1] + maxLengthWords[i];
-        }
-        gridCell.cell.column.temp['bio-sum-maxLengthWords'] = maxLengthWordSum;
-        gridCell.cell.column.temp['bio-maxIndex'] = maxIndex;
-        gridCell.cell.column.temp['bio-maxLengthWords'] = maxLengthWords;
+        for (let i = 1; i <= maxIndex; i++) maxLengthWordSum[i] = maxLengthWordSum[i - 1] + maxLengthWords[i];
+        colTemp[tempTAGS.bioSumMaxLengthWords] = maxLengthWordSum;
+        colTemp[tempTAGS.bioMaxIndex] = maxIndex;
+        colTemp[tempTAGS.bioMaxLengthWords] = maxLengthWords;
         gridCell.cell.column.setTag('.calculatedCellRender', splitLimit.toString());
       }
     } else {
-      maxLengthWords = gridCell.cell.column.temp['bio-maxLengthWords'];
+      maxLengthWords = colTemp[tempTAGS.bioMaxLengthWords];
     }
 
     const subParts: string[] = splitterFunc(cell.value);
     let x1 = x;
     let color = undefinedColor;
-    let drawStyle = bio.DrawStyle.classic;
-    if (gridCell.cell.column.getTag('aligned').includes('MSA') && gridCell.cell.column.getTag('units') === 'separator')
-      drawStyle = bio.DrawStyle.MSA;
+    let drawStyle = DrawStyle.classic;
+
+
+    if (aligned && aligned.includes('MSA') && units == NOTATION.SEPARATOR)
+      drawStyle = DrawStyle.MSA;
 
     subParts.every((amino, index) => {
       color = palette.get(amino);
       g.fillStyle = undefinedColor;
-      let last = index === subParts.length - 1;
-      x1 = bio.printLeftOrCentered(x1, y, w, h, g, amino, color, 0, true, 1.0, separator, last, drawStyle, maxLengthWords, index, gridCell, referenceSequence, maxLengthOfMonomer);
-      return x1 - minDistanceRenderer - gridCell.gridColumn.left + (gridCell.gridColumn.left - gridCell.bounds.x) <= gridCell.bounds.width;
+      const last = index === subParts.length - 1;
+      x1 = printLeftOrCentered(x1, y, w, h,
+        g, amino, color, 0, true, 1.0, separator, last, drawStyle,
+        maxLengthWords, index, gridCell, referenceSequence, maxLengthOfMonomer);
+      return minDistanceRenderer <= w;
     });
 
     g.restore();
@@ -212,14 +242,14 @@ export class MonomerCellRenderer extends DG.GridCellRenderer {
     g.textBaseline = 'middle';
     g.textAlign = 'center';
 
-    const palette = bio.getPaletteByType(gridCell.cell.column.getTag(C.TAGS.ALPHABET));
+    const palette = getPaletteByType(gridCell.cell.column.getTag(bioTAGS.alphabet));
     const s: string = gridCell.cell.value;
     if (!s)
       return;
     const color = palette.get(s);
 
     g.fillStyle = color;
-    g.fillText(s, x + (w / 2), y + (h / 2), w);
+    g.fillText(monomerToShort(s, 3), x + (w / 2), y + (h / 2), w);
   }
 }
 
@@ -250,12 +280,12 @@ export class MacromoleculeDifferenceCellRenderer extends DG.GridCellRenderer {
     const grid = gridCell.grid;
     const cell = gridCell.cell;
     const s: string = cell.value ?? '';
-    const separator = gridCell.tableColumn!.tags[C.TAGS.SEPARATOR];
+    const separator = gridCell.tableColumn!.tags[bioTAGS.separator];
     const units: string = gridCell.tableColumn!.tags[DG.TAGS.UNITS];
     w = getUpdatedWidth(grid, g, x, w);
     //TODO: can this be replaced/merged with splitSequence?
     const [s1, s2] = s.split('#');
-    const splitter = bio.getSplitter(units, separator);
+    const splitter = getSplitter(units, separator);
     const subParts1 = splitter(s1);
     const subParts2 = splitter(s2);
     drawMoleculeDifferenceOnCanvas(g, x, y, w, h, subParts1, subParts2, units);
@@ -272,12 +302,12 @@ export function drawMoleculeDifferenceOnCanvas(
   subParts2: string [],
   units: string,
   fullStringLength?: boolean,
-  molDifferences?: { [key: number]: HTMLCanvasElement }) {
-
+  molDifferences?: { [key: number]: HTMLCanvasElement }
+): void {
   if (subParts1.length !== subParts2.length) {
-    const emptyMonomersArray = new Array<string>(Math.abs(subParts1.length - subParts2.length)).fill('');
-    subParts1.length > subParts2.length ?
-      subParts2 = subParts2.concat(emptyMonomersArray) : subParts1 = subParts1.concat(emptyMonomersArray);
+    const sequences: IComparedSequences = fillShorterSequence(subParts1, subParts2);
+    subParts1 = sequences.subParts1;
+    subParts2 = sequences.subParts2;
   }
   const textSize1 = g.measureText(processSequence(subParts1).join(''));
   const textSize2 = g.measureText(processSequence(subParts2).join(''));
@@ -297,9 +327,9 @@ export function drawMoleculeDifferenceOnCanvas(
   g.font = '12px monospace';
   g.textBaseline = 'top';
 
-  let palette: bio.SeqPalette = bio.UnknownSeqPalettes.Color;
+  let palette: SeqPalette = UnknownSeqPalettes.Color;
   if (units != 'HELM')
-    palette = bio.getPaletteByType(units.substring(units.length - 2));
+    palette = getPaletteByType(units.substring(units.length - 2));
 
   const vShift = 7;
   for (let i = 0; i < subParts1.length; i++) {
@@ -309,17 +339,22 @@ export function drawMoleculeDifferenceOnCanvas(
 
     if (amino1 != amino2) {
       const color2 = palette.get(amino2);
-      const subX0 = bio.printLeftOrCentered(updatedX, updatedY - vShift, w, h, g, amino1, color1, 0, true);
-      const subX1 = bio.printLeftOrCentered(updatedX, updatedY + vShift, w, h, g, amino2, color2, 0, true);
+      const subX0 = printLeftOrCentered(updatedX, updatedY - vShift, w, h, g, amino1, color1, 0, true);
+      const subX1 = printLeftOrCentered(updatedX, updatedY + vShift, w, h, g, amino2, color2, 0, true);
       updatedX = Math.max(subX1, subX0);
       if (molDifferences)
         molDifferences[i] = createDifferenceCanvas(amino1, amino2, color1, color2, updatedY, vShift, h);
-    } else { updatedX = bio.printLeftOrCentered(updatedX, updatedY, w, h, g, amino1, color1, 0, true, 0.5); }
+    } else { updatedX = printLeftOrCentered(updatedX, updatedY, w, h, g, amino1, color1, 0, true, 0.5); }
     updatedX += 4;
   }
   g.restore();
 }
 
+interface IComparedSequences{
+  subParts1: string[];
+  subParts2: string[];
+}
+
 function createDifferenceCanvas(
   amino1: string,
   amino2: string,
@@ -338,7 +373,34 @@ function createDifferenceCanvas(
   canvas.width = width + 4;
   context.font = '12px monospace';
   context.textBaseline = 'top';
-  bio.printLeftOrCentered(0, y - shift, width, h, context, amino1, color1, 0, true);
-  bio.printLeftOrCentered(0, y + shift, width, h, context, amino2, color2, 0, true);
+  printLeftOrCentered(0, y - shift, width, h, context, amino1, color1, 0, true);
+  printLeftOrCentered(0, y + shift, width, h, context, amino2, color2, 0, true);
   return canvas;
 }
+
+function fillShorterSequence(subParts1: string[], subParts2: string[]): IComparedSequences {
+  let numIdenticalStart = 0;
+  let numIdenticalEnd = 0;
+  const longerSeq = subParts1.length > subParts2.length ? subParts1 : subParts2;
+  let shorterSeq = subParts1.length > subParts2.length ? subParts2 : subParts1;
+
+  for (let i = 0; i < shorterSeq.length; i++) {
+    if (longerSeq[i] === shorterSeq[i])
+      numIdenticalStart++;
+  }
+
+  const lengthDiff = longerSeq.length - shorterSeq.length;
+  for (let i = longerSeq.length - 1; i > lengthDiff; i--) {
+    if (longerSeq[i] === shorterSeq[i - lengthDiff])
+      numIdenticalEnd++;
+  }
+
+  const emptyMonomersArray = new Array<string>(Math.abs(subParts1.length - subParts2.length)).fill('');
+
+  function concatWithEmptyVals(subparts: string[]): string[] {
+    return numIdenticalStart > numIdenticalEnd ? subparts.concat(emptyMonomersArray) : emptyMonomersArray.concat(subparts);
+  }
+
+  subParts1.length > subParts2.length ?  subParts2 = concatWithEmptyVals(subParts2) : subParts1 = concatWithEmptyVals(subParts1);
+  return {subParts1: subParts1, subParts2: subParts2};
+}

package/src/utils/constants.ts

@@ -12,18 +12,14 @@ export enum COLUMNS_NAMES {
 export enum TAGS {
   AAR = 'AAR',
   POSITION = 'Pos',
-  SEPARATOR = 'separator',
   SELECTION = 'selection',
-  ALPHABET = 'alphabet',
-  ALIGNED = 'aligned',
 }
 
 export enum SEM_TYPES {
   MONOMER = 'Monomer',
   MACROMOLECULE_DIFFERENCE = 'MacromoleculeDifference',
   ACTIVITY = 'activity',
-  ACTIVITY_SCALED = 'activityScaled',
-  MACROMOLECULE = 'Macromolecule',
+  ACTIVITY_SCALED = 'activityScaled'
 }
 
 export const MSA = 'MSA';
@@ -47,7 +43,7 @@ export const aarGroups = {
   '-': '-',
 };
 
-export const groupDescription: {[key: string]: {'description': string, aminoAcids: string[]}} = {
+export const groupDescription: { [key: string]: { 'description': string, aminoAcids: string[] } } = {
   'PC': {'description': 'Positive Amino Acids, with Electrically Charged Side Chains', 'aminoAcids': ['R', 'H', 'K']},
   'NC': {'description': 'Negative Amino Acids, with Electrically Charged Side Chains', 'aminoAcids': ['D', 'E']},
   'U': {'description': 'Amino Acids with Polar Uncharged Side Chains', 'aminoAcids': ['S', 'T', 'N', 'Q']},
@@ -58,3 +54,8 @@ export const groupDescription: {[key: string]: {'description': string, aminoAcid
   },
   '-': {'description': 'Unknown Amino Acid', 'aminoAcids': ['-']},
 };
+
+export namespace PEPSEA {
+  export const SEPARATOR = '.';
+}
+

package/src/utils/convert.ts

@@ -1,10 +1,11 @@
 import * as DG from 'datagrok-api/dg';
 import * as ui from 'datagrok-api/ui';
 import * as grok from 'datagrok-api/grok';
-import * as bio from '@datagrok-libraries/bio';
 
 import $ from 'cash-dom';
 import {Subscription} from 'rxjs';
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {NotationConverter} from '@datagrok-libraries/bio/src/utils/notation-converter';
 
 
 let convertDialog: DG.Dialog | null = null;
@@ -16,13 +17,13 @@ let convertDialogSubs: Subscription[] = [];
  * @param {DG.column} col Column with 'Macromolecule' semantic type
  */
 export function convert(col: DG.Column): void {
-  const converter = new bio.NotationConverter(col);
-  const currentNotation: bio.NOTATION = converter.notation;
+  const converter = new NotationConverter(col);
+  const currentNotation: NOTATION = converter.notation;
   //TODO: read all notations
   const notations = [
-    bio.NOTATION.FASTA,
-    bio.NOTATION.SEPARATOR,
-    bio.NOTATION.HELM
+    NOTATION.FASTA,
+    NOTATION.SEPARATOR,
+    NOTATION.HELM
   ];
   const separatorArray = ['-', '.', '/'];
   const filteredNotations = notations.filter((e) => e !== currentNotation);
@@ -32,7 +33,7 @@ export function convert(col: DG.Column): void {
 
   // hide the separator input for non-SEPARATOR target notations
   const toggleSeparator = () => {
-    if (targetNotationInput.value !== bio.NOTATION.SEPARATOR)
+    if (targetNotationInput.value !== NOTATION.SEPARATOR)
       $(separatorInput.root).hide();
     else
       $(separatorInput.root).show();
@@ -46,7 +47,7 @@ export function convert(col: DG.Column): void {
   });
 
   if (convertDialog == null) {
-    convertDialog = ui.dialog('Convert sequence notation')
+    convertDialog = ui.dialog('Convert Sequence Notation')
       .add(ui.div([
         ui.divText(
           'Current notation: ' + currentNotation,
@@ -63,7 +64,7 @@ export function convert(col: DG.Column): void {
         separatorInput.root
       ]))
       .onOK(async () => {
-        const targetNotation = targetNotationInput.value as bio.NOTATION;
+        const targetNotation = targetNotationInput.value as NOTATION;
         const separator: string | null = separatorInput.value;
 
         await convertDo(col, targetNotation, separator);
@@ -80,12 +81,17 @@ export function convert(col: DG.Column): void {
 
 /** Creates a new column with converted sequences and detects its semantic type */
 export async function convertDo(
-  srcCol: DG.Column, targetNotation: bio.NOTATION, separator: string | null
+  srcCol: DG.Column, targetNotation: NOTATION, separator: string | null
 ): Promise<DG.Column> {
-  const converter = new bio.NotationConverter(srcCol);
+  const converter = new NotationConverter(srcCol);
   const newColumn = converter.convert(targetNotation, separator);
   srcCol.dataFrame.columns.add(newColumn);
 
+  // Call detector directly to escape some error on detectSemanticTypes
+  const semType = await grok.functions.call('Bio:detectMacromolecule', {col: newColumn});
+  if (semType)
+    newColumn.semType = semType;
+
   // call to calculate 'cell.renderer' tag
   await grok.data.detectSemanticTypes(srcCol.dataFrame);
 

package/src/utils/monomer-lib.ts

@@ -0,0 +1,174 @@
+// import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+import * as grok from 'datagrok-api/grok';
+
+import {Observable, Subject} from 'rxjs';
+import {IMonomerLib, Monomer} from '@datagrok-libraries/bio/src/types/index';
+import {
+  createJsonMonomerLibFromSdf,
+  expectedMonomerData,
+  IMonomerLibHelper
+} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+
+// -- Monomer libraries --
+export const LIB_STORAGE_NAME = 'Libraries';
+export const LIB_PATH = 'System:AppData/Bio/libraries/';
+export const LIB_DEFAULT: { [fileName: string]: string } = {'HELMCoreLibrary.json': 'HELMCoreLibrary.json'};
+
+export class MonomerLib implements IMonomerLib {
+  private _monomers: { [type: string]: { [name: string]: Monomer } } = {};
+  private _onChanged = new Subject<any>();
+
+  constructor(monomers: { [type: string]: { [name: string]: Monomer } }) {
+    this._monomers = monomers;
+  }
+
+  getMonomer(monomerType: string, monomerName: string): Monomer | null {
+    if (monomerType in this._monomers! && monomerName in this._monomers![monomerType])
+      return this._monomers![monomerType][monomerName];
+    else
+      return null;
+  }
+
+  getTypes(): string[] {
+    return Object.keys(this._monomers);
+  }
+
+  getMonomerMolsByType(type: string): { [symbol: string]: string } {
+    const res: { [symbol: string]: string } = {};
+
+    Object.keys(this._monomers[type]).forEach((monomerSymbol) => {
+      res[monomerSymbol] = this._monomers[type][monomerSymbol].molfile;
+    });
+
+    return res;
+  }
+
+  getMonomerNamesByType(type: string): string[] {
+    return Object.keys(this._monomers[type]);
+  }
+
+  get onChanged(): Observable<any> {
+    return this._onChanged;
+  }
+
+  private _updateInt(lib: IMonomerLib): void {
+    const typesNew = lib.getTypes();
+    const types = this.getTypes();
+
+    typesNew.forEach((type) => {
+      //could possibly rewrite -> TODO: check duplicated monomer symbol
+
+      if (!types.includes(type))
+        this._monomers![type] = {};
+
+      const monomers = lib.getMonomerNamesByType(type);
+      monomers.forEach((monomerName) => {
+        this._monomers[type][monomerName] = lib.getMonomer(type, monomerName)!;
+      });
+    });
+  }
+
+  public update(lib: IMonomerLib): void {
+    this._updateInt(lib);
+    this._onChanged.next();
+  }
+
+  public updateLibs(libList: IMonomerLib[], reload: boolean = false): void {
+    if (reload) this._monomers = {};
+    for (const lib of libList) this._updateInt(lib);
+    this._onChanged.next();
+  }
+
+  public clear(): void {
+    this._monomers = {};
+    this._onChanged.next();
+  }
+}
+
+export class MonomerLibHelper implements IMonomerLibHelper {
+  private readonly _monomerLib: MonomerLib = new MonomerLib({});
+
+  /** Protect constructor to prevent multiple instantiation. */
+  protected constructor() {}
+
+  /** Singleton monomer library */
+  getBioLib(): IMonomerLib {
+    return this._monomerLib;
+  }
+
+  private loadLibrariesPromise: Promise<void> = Promise.resolve();
+
+  /** Loads libraries based on settings in user storage {@link LIB_STORAGE_NAME}
+   * @param {boolean} reload Clean {@link monomerLib} before load libraries [false]
+   */
+  async loadLibraries(reload: boolean = false): Promise<void> {
+    return this.loadLibrariesPromise = this.loadLibrariesPromise.then(async () => {
+      const userLibrariesSettings: string[] = Object.keys(await grok.dapi.userDataStorage.get(LIB_STORAGE_NAME, true));
+      const libs: IMonomerLib[] = await Promise.all(userLibrariesSettings.map((libFileName) => {
+        //TODO handle whether files are in place
+        return this.readLibrary(LIB_PATH, libFileName);
+      }));
+      this._monomerLib.updateLibs(libs, reload);
+    });
+  }
+
+  /** Reads library from file shares, handles .json and .sdf */
+  async readLibrary(path: string, fileName: string): Promise<IMonomerLib> {
+    let data: any[] = [];
+    let file;
+    let dfSdf;
+    const fileSource = new DG.FileSource(path);
+    if (fileName.endsWith('.sdf')) {
+      const funcList: DG.Func[] = DG.Func.find({package: 'Chem', name: 'importSdf'});
+      if (funcList.length === 1) {
+        file = await fileSource.readAsBytes(fileName);
+        dfSdf = await grok.functions.call('Chem:importSdf', {bytes: file});
+        data = createJsonMonomerLibFromSdf(dfSdf[0]);
+      } else {
+        grok.shell.warning('Chem package is not installed');
+      }
+    } else {
+      const file = await fileSource.readAsText(fileName);
+      data = JSON.parse(file);
+    }
+
+    const monomers: { [type: string]: { [name: string]: Monomer } } = {};
+    const types: string[] = [];
+    //group monomers by their type
+    data.forEach((monomer) => {
+      const monomerAdd: Monomer = {
+        'symbol': monomer['symbol'],
+        'name': monomer['name'],
+        'naturalAnalog': monomer['naturalAnalog'],
+        'molfile': monomer['molfile'],
+        'rgroups': monomer['rgroups'],
+        'polymerType': monomer['polymerType'],
+        'monomerType': monomer['monomerType'],
+        'data': {}
+      };
+
+      Object.keys(monomer).forEach((prop) => {
+        if (!expectedMonomerData.includes(prop))
+          monomerAdd.data[prop] = monomer[prop];
+      });
+
+      if (!types.includes(monomer['polymerType'])) {
+        monomers[monomer['polymerType']] = {};
+        types.push(monomer['polymerType']);
+      }
+
+      monomers[monomer['polymerType']][monomer['symbol']] = monomerAdd;
+    });
+
+    return new MonomerLib(monomers);
+  }
+
+  // -- Instance singleton --
+  private static _instance: MonomerLibHelper | null = null;
+
+  public static get instance(): MonomerLibHelper {
+    if (!MonomerLibHelper._instance) MonomerLibHelper._instance = new MonomerLibHelper();
+    return MonomerLibHelper._instance;
+  }
+}