@datagrok/bio 2.12.16 → 2.12.18

package/src/utils/monomer-lib/library-file-manager/ui.ts

@@ -4,16 +4,15 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import $ from 'cash-dom';
-import * as rxjs from 'rxjs';
+import {Subject} from 'rxjs';
 import './style.css';
 
 import {
   getUserLibSettings, setUserLibSettings
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
-import {MonomerLibManager} from '../lib-manager';
+import {getMonomerLibHelper, IMonomerLibFileManager} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 
-import {MonomerLibFileManager} from './file-manager';
 import {MonomerLibFileEventManager} from './event-manager';
 
 export async function showManageLibrariesDialog(): Promise<void> {
@@ -30,37 +29,39 @@ export async function getMonomerLibraryManagerLink(): Promise<DG.Widget> {
 }
 
 class MonomerLibraryManagerWidget {
-  private constructor(
-    private eventManager: MonomerLibFileEventManager
-  ) { }
+  private _fileManager: IMonomerLibFileManager;
 
-  private static _instance: MonomerLibraryManagerWidget;
+  private _widget: DG.Widget;
+  public get widget(): DG.Widget { return this._widget; }
 
-  static async getContent(eventManager: MonomerLibFileEventManager): Promise<DG.Widget> {
-    if (!MonomerLibraryManagerWidget._instance)
-      MonomerLibraryManagerWidget._instance = new MonomerLibraryManagerWidget(eventManager);
+  private constructor() {}
 
-    if (!MonomerLibraryManagerWidget._instance.widget)
-      MonomerLibraryManagerWidget._instance.widget = await MonomerLibraryManagerWidget._instance.createWidget();
+  private static instancePromise?: Promise<MonomerLibraryManagerWidget>;
 
-    return MonomerLibraryManagerWidget._instance.widget;
+  static async getInstance(): Promise<MonomerLibraryManagerWidget> {
+    if (MonomerLibraryManagerWidget.instancePromise === undefined) {
+      MonomerLibraryManagerWidget.instancePromise = (async () => {
+        const instance = new MonomerLibraryManagerWidget();
+        const libHelper = await getMonomerLibHelper();
+        instance._fileManager = await libHelper.getFileManager();
+        instance._widget = await instance.createWidget();
+        return instance;
+      })();
+    }
+    return MonomerLibraryManagerWidget.instancePromise;
   }
 
-  private monomerLibFileManager: MonomerLibFileManager;
-  private widget: DG.Widget | undefined;
-
   private async createWidget() {
-    this.monomerLibFileManager = await MonomerLibFileManager.getInstance(this.eventManager);
     const content = await this.getWidgetContent();
-    this.eventManager.addLibraryFileRequested$.subscribe(
+    const monomerLibHelper = await getMonomerLibHelper();
+    monomerLibHelper.eventManager.addLibraryFileRequested$.subscribe(
       async () => await this.promptToAddLibraryFiles()
     );
     return new DG.Widget(content);
   }
 
   private async getWidgetContent(): Promise<HTMLElement> {
-    this.monomerLibFileManager = await MonomerLibFileManager.getInstance(this.eventManager);
-    const libControlsForm = await LibraryControlsManager.createControlsForm(this.eventManager);
+    const libControlsForm = await LibraryControlsManager.createControlsForm();
     $(libControlsForm).addClass('monomer-lib-controls-form');
     const widgetContent = ui.divV([libControlsForm]);
     return widgetContent;
@@ -74,7 +75,7 @@ class MonomerLibraryManagerWidget {
         const name = selectedFile.name;
         const progressIndicator = DG.TaskBarProgressIndicator.create(`Adding ${name} as a monomer library`);
         try {
-          await this.monomerLibFileManager.addLibraryFile(content, name);
+          await this._fileManager.addLibraryFile(content, name);
           // this.eventManager.updateLibrarySelectionStatus(name, true);
         } catch (e) {
           grok.shell.error(`File ${name} is not a valid monomer library, verify it is aligned to HELM JSON schema.`);
@@ -87,27 +88,30 @@ class MonomerLibraryManagerWidget {
 }
 
 class LibraryControlsManager {
-  private constructor(private eventManager: MonomerLibFileEventManager) {
-    this.eventManager.updateUIControlsRequested$.subscribe(
-      async () => await this.updateControlsForm()
-    );
-    this.eventManager.librarySelectionRequested$.subscribe(
-      async ([fileName, isSelected]) => await this.updateLibrarySelectionStatus(isSelected, fileName)
-    );
+  private constructor(
+    private fileManager: IMonomerLibFileManager
+  ) {
+    this.fileManager.eventManager.updateUIControlsRequested$.subscribe(() => {
+      this.updateControlsForm();
+    });
+    this.fileManager.eventManager.librarySelectionRequested$.subscribe(async ([fileName, isSelected]) => {
+      await this.updateLibrarySelectionStatus(isSelected, fileName);
+    });
   }
-  private monomerLibFileManager: MonomerLibFileManager;
+
   private userLibSettings: UserLibSettings;
 
-  static async createControlsForm(eventManager: MonomerLibFileEventManager): Promise<HTMLElement> {
-    const manager = new LibraryControlsManager(eventManager);
+  static async createControlsForm(): Promise<HTMLElement> {
+    const libHelper = await getMonomerLibHelper();
+    const fileManager = await libHelper.getFileManager();
+    const manager = new LibraryControlsManager(fileManager);
     await manager.initialize();
 
-    return await manager._createControlsForm();
+    return manager._createControlsForm();
   }
 
-  private async _createControlsForm(): Promise<HTMLElement> {
-    this.monomerLibFileManager = await MonomerLibFileManager.getInstance(this.eventManager);
-    const libraryControls = await this.createLibraryControls();
+  private _createControlsForm(): HTMLElement {
+    const libraryControls = this.createLibraryControls();
     const inputsForm = ui.form(libraryControls);
     $(inputsForm).addClass('monomer-lib-controls-form');
 
@@ -118,14 +122,13 @@ class LibraryControlsManager {
     this.userLibSettings = await getUserLibSettings();
   };
 
-  private async updateControlsForm(): Promise<void> {
-    const updatedForm = await this._createControlsForm();
+  private updateControlsForm(): void {
+    const updatedForm = this._createControlsForm();
     $('.monomer-lib-controls-form').replaceWith(updatedForm);
   }
 
-  private async createLibraryControls(): Promise<DG.InputBase<boolean | null>[]> {
-    const fileManager = await MonomerLibFileManager.getInstance(this.eventManager);
-    const libFileNameList: string[] = fileManager.getValidLibraryPaths();
+  private createLibraryControls(): DG.InputBase<boolean | null>[] {
+    const libFileNameList: string[] = this.fileManager.getValidLibraryPaths();
     return libFileNameList.map((libFileName) => this.createLibInput(libFileName));
   }
 
@@ -134,8 +137,9 @@ class LibraryControlsManager {
     const libInput = ui.boolInput(
       libFileName,
       isMonomerLibrarySelected,
-      (isSelected: boolean) => this.eventManager.updateLibrarySelectionStatus(libFileName, isSelected)
-    );
+      (isSelected: boolean) => {
+        this.fileManager.eventManager.updateLibrarySelectionStatus(libFileName, isSelected);
+      });
     ui.tooltip.bind(libInput.root, `Include monomers from ${libFileName}`);
     const deleteIcon = ui.iconFA('trash-alt', () => this.promptForLibraryDeletion(libFileName));
     ui.tooltip.bind(deleteIcon, `Delete ${libFileName}`);
@@ -149,7 +153,8 @@ class LibraryControlsManager {
   ): Promise<void> {
     this.updateLibrarySettings(isMonomerLibrarySelected, libFileName);
     await setUserLibSettings(this.userLibSettings);
-    await MonomerLibManager.instance.loadLibraries(true);
+    const monomerLibHelper = await getMonomerLibHelper();
+    await monomerLibHelper.loadLibraries(true);
     grok.shell.info('Monomer library user settings saved');
   }
 
@@ -172,8 +177,8 @@ class LibraryControlsManager {
       .onOK(async () => {
         try {
           const progressIndicator = DG.TaskBarProgressIndicator.create(`Deleting ${fileName} library`);
-          this.updateLibrarySelectionStatus(false, fileName);
-          await this.monomerLibFileManager.deleteLibraryFile(fileName);
+          await this.updateLibrarySelectionStatus(false, fileName);
+          await this.fileManager.deleteLibraryFile(fileName);
           progressIndicator.close();
         } catch (e) {
           console.error(e);
@@ -189,7 +194,7 @@ class DialogWrapper {
 
   private static _instance: DialogWrapper;
   private dialog?: DG.Dialog;
-  private closeDialogSubject$ = new rxjs.Subject<void>();
+  private closeDialogSubject$ = new Subject<void>();
 
   static async showDialog(): Promise<void> {
     if (!DialogWrapper._instance) {
@@ -207,7 +212,7 @@ class DialogWrapper {
 
   private async getDialog(): Promise<DG.Dialog> {
     const eventManager = MonomerLibFileEventManager.getInstance();
-    const widget = await MonomerLibraryManagerWidget.getContent(eventManager);
+    const widget = (await MonomerLibraryManagerWidget.getInstance()).widget;
     const dialog = ui.dialog(
       {
         title: 'Manage monomer libraries',

package/src/utils/monomer-lib/monomer-lib.ts

@@ -1,10 +1,17 @@
 /* Do not change these import lines to match external modules in webpack configuration */
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
 
+import wu from 'wu';
 import {Observable, Subject} from 'rxjs';
 
-import {IMonomerLib, Monomer} from '@datagrok-libraries/bio/src/types/index';
+import {
+  IMonomerLib, Monomer, MonomerLibSummaryType, MonomerType, PolymerType, RGroup
+} from '@datagrok-libraries/bio/src/types';
+import {
+  HELM_REQUIRED_FIELD as REQ, HELM_RGROUP_FIELDS as RGP
+} from '@datagrok-libraries/bio/src/utils/const';
 import {MolfileHandler} from '@datagrok-libraries/chem-meta/src/parsing-utils/molfile-handler';
 
 import '../../../css/cell-renderer.css';
@@ -27,18 +34,57 @@ export class MonomerLib implements IMonomerLib {
     }
   }
 
-  getMonomer(polymerType: string, monomerSymbol: string): Monomer | null {
+  /** Creates missing {@link Monomer} */
+  addMissingMonomer(polymerType: PolymerType, monomerSymbol: string): Monomer {
+    let mSet = this._monomers[polymerType];
+    if (!mSet)
+      mSet = this._monomers[polymerType] = {};
+    const m = mSet[monomerSymbol] = {
+      [REQ.SYMBOL]: monomerSymbol,
+      [REQ.NAME]: monomerSymbol,
+      [REQ.MOLFILE]: '',
+      [REQ.AUTHOR]: 'MISSING',
+      [REQ.ID]: -1,
+      [REQ.RGROUPS]:
+        wu.count(1).take(9).map((i) => {
+          return {
+            /* eslint-disable no-multi-spaces */
+            // Samples                        //  PEPTIDE     RNA
+            [RGP.CAP_GROUP_SMILES]: '',       // '[*:1][H]'  '[*:1][H]'
+            [RGP.ALTERNATE_ID]: '',           // 'R1-H'      'R1-H'
+            [RGP.CAP_GROUP_NAME]: '',         // 'H'         'H'
+            [RGP.LABEL]: `R${i.toString()}`,  // 'R1'        'R1'
+            /* eslint-enable no-multi-spaces */
+          } as RGroup;
+        }).toArray(),
+      [REQ.SMILES]: '',
+      [REQ.POLYMER_TYPE]: polymerType,
+      [REQ.MONOMER_TYPE]: undefined as unknown as MonomerType, // TODO: Can we get monomerType from atom of POM
+      [REQ.CREATE_DATE]: null,
+    } as Monomer;
+    return m;
+  }
+
+  getMonomer(polymerType: PolymerType, argMonomerSymbol: string): Monomer | null {
+    // Adjust RNA's 'R' for ribose to 'r' and 'P' for phosphate to 'p' for case-sensitive monomer names.
+    // There are uppercase 'R' and 'P' at RNA samples in test data 'helm2.csv' but lowercase in HELMCoreLibrary.json
+    let monomerSymbol = argMonomerSymbol;
+    if (polymerType == 'RNA' && monomerSymbol == 'R')
+      monomerSymbol = 'r';
+    if (polymerType == 'RNA' && monomerSymbol == 'P')
+      monomerSymbol = 'p';
+
     if (polymerType in this._monomers! && monomerSymbol in this._monomers![polymerType])
       return this._monomers![polymerType][monomerSymbol];
     else
       return null;
   }
 
-  getPolymerTypes(): string[] {
-    return Object.keys(this._monomers);
+  getPolymerTypes(): PolymerType[] {
+    return Object.keys(this._monomers) as PolymerType[];
   }
 
-  getMonomerMolsByPolymerType(polymerType: string): { [monomerSymbol: string]: string } {
+  getMonomerMolsByPolymerType(polymerType: PolymerType): { [monomerSymbol: string]: string } {
     const res: { [monomerSymbol: string]: string } = {};
 
     Object.keys(this._monomers[polymerType] ?? {}).forEach((monomerSymbol) => {
@@ -48,14 +94,14 @@ export class MonomerLib implements IMonomerLib {
     return res;
   }
 
-  getMonomerSymbolsByType(polymerType: string): string[] {
+  getMonomerSymbolsByType(polymerType: PolymerType): string[] {
     return Object.keys(this._monomers[polymerType]);
   }
 
   /** Get a list of monomers with specified element attached to specified
    * R-group
    * WARNING: RGroup numbering starts from 1, not 0*/
-  getMonomerSymbolsByRGroup(rGroupNumber: number, polymerType: string, element?: string): string[] {
+  getMonomerSymbolsByRGroup(rGroupNumber: number, polymerType: PolymerType, element?: string): string[] {
     const monomerSymbols = this.getMonomerSymbolsByType(polymerType);
     let monomers = monomerSymbols.map((sym) => this.getMonomer(polymerType, sym));
     monomers = monomers.filter((el) => el !== null);
@@ -116,7 +162,38 @@ export class MonomerLib implements IMonomerLib {
     this._onChanged.next();
   }
 
-  getTooltip(polymerType: string, monomerSymbol: string): HTMLElement {
+  getSummaryObj(): MonomerLibSummaryType {
+    const res: MonomerLibSummaryType = {};
+    const ptList: PolymerType[] = this.getPolymerTypes();
+    for (const pt of ptList)
+      res[pt] = this.getMonomerSymbolsByType(pt).length;
+    return res;
+  }
+
+  getSummaryDf(): DG.DataFrame {
+    const ptList = this.getPolymerTypes();
+
+    const countList: number[] = new Array<number>(ptList.length);
+    for (const [pt, i] of wu.enumerate(ptList))
+      countList[i] = this.getMonomerSymbolsByType(pt).length;
+
+    const resDf: DG.DataFrame = DG.DataFrame.fromColumns([
+      DG.Column.fromStrings('polymerType', ptList),
+      DG.Column.fromList(DG.COLUMN_TYPE.INT, 'count', countList),
+    ]);
+    return resDf;
+  }
+
+  /** @deprecated Keep for backward compatibility */
+  getSummary(): string {
+    const monTypeList: PolymerType[] = this.getPolymerTypes();
+    const resStr: string = monTypeList.length == 0 ? 'empty' : monTypeList.map((monType) => {
+      return `${monType} ${this.getMonomerSymbolsByType(monType).length}`;
+    }).join('\n');
+    return resStr;
+  }
+
+  getTooltip(polymerType: PolymerType, monomerSymbol: string): HTMLElement {
     // getTooltip(monomer: Monomer): HTMLElement;
     // getTooltip(monomerOrPolymerType: string | Monomer, symbol?: string): HTMLElement {
     //   let polymerType: string;
@@ -163,8 +240,12 @@ export class MonomerLib implements IMonomerLib {
         label('Source'),
         ui.divText(monomer.lib?.source ?? 'unknown', {classes: 'ui-input-text'}),
       ], {classes: 'ui-input-root'}));
-    } else
-      res.append(ui.divText('Monomer not found'));
+    } else {
+      res.append(ui.divV([
+        ui.divText(`Monomer '${monomerSymbol}' of type '${polymerType}' not found.`),
+        ui.divText('Open the Context Panel, then expand Manage Libraries'),
+      ]));
+    }
     return res;
   }
 }

package/src/utils/sequence-to-mol.ts

@@ -4,14 +4,16 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {_toAtomicLevel} from '@datagrok-libraries/bio/src/monomer-works/to-atomic-level';
-import {helm2mol} from './helm-to-molfile/utils';
 import {IMonomerLib} from '@datagrok-libraries/bio/src/types';
-import {checkInputColumnUI} from './check-input-column';
-import {getMonomerLibHelper} from '../package';
 import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
-export async function sequenceToMolfile(df: DG.DataFrame, macroMolecule: DG.Column, nonlinear: boolean): Promise<void> {
+import {helm2mol} from './helm-to-molfile/utils';
+import {checkInputColumnUI} from './check-input-column';
+
+export async function sequenceToMolfile(
+  df: DG.DataFrame, macroMolecule: DG.Column, nonlinear: boolean, monomerLib: IMonomerLib
+): Promise<void> {
   if (DG.Func.find({package: 'Chem', name: 'getRdKitModule'}).length === 0) {
     grok.shell.warning('Transformation to atomic level requires package "Chem" installed.');
     return;
@@ -20,12 +22,10 @@ export async function sequenceToMolfile(df: DG.DataFrame, macroMolecule: DG.Colu
     const seqSh = SeqHandler.forColumn(macroMolecule);
     if (!seqSh.isHelm())
       macroMolecule = seqSh.convert(NOTATION.HELM);
-    helm2mol(df, macroMolecule);
-    return;
+    return helm2mol(df, macroMolecule);
   }
   if (!checkInputColumnUI(macroMolecule, 'To Atomic Level'))
     return;
-  const monomerLib: IMonomerLib = getMonomerLibHelper().getBioLib();
   const atomicLevelRes = await _toAtomicLevel(df, macroMolecule, monomerLib);
   if (atomicLevelRes.col !== null) {
     df.columns.add(atomicLevelRes.col, true);

package/src/widgets/bio-substructure-filter-helm.ts

@@ -2,14 +2,15 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
+import * as org from 'org';
 import $ from 'cash-dom';
-import {fromEvent, Observable, Subject, Unsubscribable} from 'rxjs';
+import {fromEvent, Unsubscribable} from 'rxjs';
 
-import {IHelmWebEditor, IWebEditorApp} from '@datagrok-libraries/bio/src/helm/types';
+import {IHelmWebEditor} from '@datagrok-libraries/bio/src/helm/types';
 import {getHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 import {ILogger} from '@datagrok-libraries/bio/src/utils/logger';
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
-import {delay, testEvent} from '@datagrok-libraries/utils/src/test';
+import {delay} from '@datagrok-libraries/utils/src/test';
 
 import {updateDivInnerHTML} from '../utils/ui-utils';
 import {helmSubstructureSearch} from '../substructure-search/substructure-search';
@@ -54,7 +55,7 @@ export class HelmBioFilter extends BioFilterBase<BioFilterProps> /* implements I
       this.logger.warning('TEST: HelmBioFilter.init().sync() waitForElementInDom ready');
       this.updateFilterPanel();
       let webEditorHost: HTMLDivElement | null;
-      let webEditorApp: IWebEditorApp | null;
+      let webEditorApp: org.helm.IWebEditorApp | null;
       // TODO: Unsubscribe 'click' and 'sizeChanged'
       this.viewSubs.push(fromEvent(this._filterPanel, 'click').subscribe(() => {
         webEditorHost = ui.div();

package/src/widgets/bio-substructure-filter.ts

@@ -16,7 +16,6 @@ import {TAGS as bioTAGS, NOTATION} from '@datagrok-libraries/bio/src/utils/macro
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
 import {delay, testEvent} from '@datagrok-libraries/utils/src/test';
 import {getHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
-import {IHelmWebEditor, IWebEditorApp} from '@datagrok-libraries/bio/src/helm/types';
 import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 import {IRenderer} from '@datagrok-libraries/bio/src/types/renderer';
 import {ILogger} from '@datagrok-libraries/bio/src/utils/logger';
@@ -274,12 +273,12 @@ export class BioSubstructureFilter extends DG.Filter implements IRenderer {
   async awaitRendered(timeout: number = 10000): Promise<void> {
     const callLog = `awaitRendered( ${timeout} )`;
     const logPrefix = `${this.filterToLog()}.${callLog}`;
-    await delay(0);
+    await delay(10);
     await testEvent(this.onRendered, () => {
       this.logger.debug(`${logPrefix}, ` + '_onRendered event caught');
     }, () => {
       this.invalidate(callLog);
-    }, timeout, `${logPrefix} ${timeout} timeout`);
+    }, timeout, `${logPrefix} timeout`);
 
     // Rethrow stored syncer error (for test purposes)
     const viewErrors = this.filterSyncer.resetErrors();

package/webpack.config.js

@@ -41,6 +41,9 @@ module.exports = {
     'cash-dom': '$',
     'dayjs': 'dayjs',
     'wu': 'wu',
+    'scil': 'scil',
+    'org': 'org',
+    // 'JSDraw2': 'JSDraw2',
   },
   output: {
     filename: '[name].js',

package/src/utils/poly-tool/const.ts

@@ -1,40 +0,0 @@
-import {HELM_REQUIRED_FIELD} from '@datagrok-libraries/bio/src/utils/const';
-
-export const ALL_MONOMERS = '<All>';
-
-export const enum TRANSFORMATION_TYPE {
-  CYCLIZATION = 'Cyclization',
-}
-
-export const enum CYCLIZATION_TYPE {
-  NO = 'N-O',
-  NCys = 'N-Cys',
-  R3 = 'R3-R3',
-}
-
-export const helmFieldsToPolyToolInputFields = {
-  [HELM_REQUIRED_FIELD.SYMBOL]: 'Short Name',
-  [HELM_REQUIRED_FIELD.NAME]: 'Medium Name',
-  [HELM_REQUIRED_FIELD.SMILES]: 'SMILES',
-};
-
-export const R_GROUP_BLOCK_DUMMY = [
-  {
-    'capGroupSMILES': '[*:1][H]',
-    'alternateId': 'R1-H',
-    'capGroupName': 'H',
-    'label': 'R1'
-  },
-  {
-    'capGroupSMILES': 'O[*:2]',
-    'alternateId': 'R2-OH',
-    'capGroupName': 'OH',
-    'label': 'R2'
-  },
-  {
-    'capGroupSMILES': '[*:3][H]',
-    'alternateId': 'R3-H',
-    'capGroupName': 'H',
-    'label': 'R3'
-  }
-];

package/src/utils/poly-tool/csv-to-json-monomer-lib-converter.ts

@@ -1,40 +0,0 @@
-import * as DG from 'datagrok-api/dg';
-
-import {PolyToolMonomerLibHandler} from './monomer-lib-handler';
-
-/** Handler of custom monomer libs for PolyTool  */
-export class PolyToolCsvLibHandler {
-  constructor(private fileName: string, private fileContent: string) {
-    this.validateFileType();
-    const df = DG.DataFrame.fromCsv(this.fileContent);
-    const json = this.toJson(df);
-    this.polyToolMonomerLib = new PolyToolMonomerLibHandler(json);
-    this.validateContent();
-  }
-
-  private polyToolMonomerLib: PolyToolMonomerLibHandler;
-
-  async getJson(): Promise<any> {
-    const rawLibData = this.polyToolMonomerLib.getJsonMonomerLib();
-    return rawLibData;
-  }
-
-  private toJson(df: DG.DataFrame): any[] {
-    return Array.from({length: df.rowCount}, (_, idx) =>
-      df.columns.names().reduce((entry: { [key: string]: any }, colName) => {
-        entry[colName] = df.get(colName, idx);
-        return entry;
-      }, {})
-    );
-  }
-
-  private validateFileType(): void {
-    if (!this.fileName.endsWith('.csv'))
-      throw new Error(`File ${this.fileName} is not an CSV file`);
-  }
-
-  private validateContent(): void {
-    if (!this.polyToolMonomerLib.isValid())
-      throw new Error('Invalid format of CSV monomer lib');
-  }
-}

package/src/utils/poly-tool/monomer-lib-handler.ts

@@ -1,115 +0,0 @@
-/* Do not change these import lines to match external modules in webpack configuration */
-import * as grok from 'datagrok-api/grok';
-import * as ui from 'datagrok-api/ui';
-import * as DG from 'datagrok-api/dg';
-
-import {HELM_FIELDS, DUMMY_MONOMER} from '@datagrok-libraries/bio/src/utils/const';
-import {
-  helmFieldsToPolyToolInputFields, R_GROUP_BLOCK_DUMMY
-} from './const';
-import {Monomer, RGroup} from '@datagrok-libraries/bio/src/types/index';
-
-export class PolyToolMonomerLibHandler {
-  constructor(private rawLib: any[]) { }
-
-  isValid(): boolean {
-    return this.rawLib.every((entry) => {
-      return typeof entry === 'object' &&
-        Object.values(helmFieldsToPolyToolInputFields).every((field) => {
-          return field in entry &&
-            typeof entry[field] === 'string';
-        });
-    });
-  }
-
-  getJsonMonomerLib(): any {
-    const resultLib: any[] = [];
-    this.rawLib.forEach((rawMonomer) => {
-      const monomer = this.prepareMonomer(rawMonomer);
-      resultLib.push(monomer);
-    });
-    return resultLib;
-  }
-
-  private prepareMonomer(rawMonomer: any): Monomer {
-    const monomer: Monomer = {...DUMMY_MONOMER};
-
-    Object.entries(helmFieldsToPolyToolInputFields).forEach(([key, value]) => {
-      const monomerSymbol = rawMonomer[value] as string;
-      //@ts-ignore
-      monomer[key] = monomerSymbol;
-    });
-
-    let key = HELM_FIELDS.SMILES;
-    const rawSmiles = rawMonomer[helmFieldsToPolyToolInputFields[key]];
-    const smilesHandler = new SmilesHandler(rawSmiles);
-    const smiles = smilesHandler.getCappedSmiles();
-    monomer[key] = smiles;
-
-    key = HELM_FIELDS.RGROUPS;
-    monomer[key] = RGroupHandler.getRGroups(smilesHandler.getNumberOfRGroups());
-
-    key = HELM_FIELDS.MOLFILE;
-    monomer[key] = new MolBlockHandler(smilesHandler.getSmilesWithRGroups()).getMolfile();
-
-    return monomer;
-  }
-}
-
-class SmilesHandler {
-  constructor(rawSmiles: string) {
-    const regex = /\[R(\d+)\]/g;
-    let i = 0;
-    this.smilesWithRGroups = rawSmiles.replace(regex, (_, capturedDigit) => { ++i; return `[${capturedDigit}*]`; });
-    this.numberOfRGroups = i;
-  }
-
-  private numberOfRGroups: number;
-  private smilesWithRGroups: string;
-
-  getSmilesWithRGroups(): string {
-    return this.smilesWithRGroups;
-  }
-
-  getCappedSmiles(): string {
-    const smiles = this.capRGroups();
-    return smiles;
-  }
-
-  getNumberOfRGroups(): number {
-    return this.numberOfRGroups;
-  }
-
-  private capRGroups(): string {
-    let result = this.smilesWithRGroups.replace('[1*]', '[H:1]');
-    result = result.replace('[2*]', '[OH:2]');
-    return result.replace('[3*]', '[H:3]');
-  }
-}
-
-class RGroupHandler {
-  private constructor() {};
-
-  static getRGroups(numberOfRGroups: number): RGroup[] {
-    return R_GROUP_BLOCK_DUMMY.slice(0, numberOfRGroups);
-  }
-}
-
-class MolBlockHandler {
-  constructor(private smilesWithRGroups: string) { }
-
-  getMolfile(): string {
-    let molfile = DG.chem.convert(this.smilesWithRGroups, DG.chem.Notation.Smiles, DG.chem.Notation.MolBlock);
-    molfile = this.restoreRGPLine(molfile);
-    molfile = this.fixRGroupSymbols(molfile);
-    return molfile;
-  }
-
-  private restoreRGPLine(rawMolfile: string): string {
-    return rawMolfile.replace('M  ISO', 'M  RGP');
-  }
-
-  private fixRGroupSymbols(molfile: string): string {
-    return molfile.replace(/\bR\b/g, 'R#');
-  }
-}