@datagrok/sequence-translator 1.3.4 → 1.3.9

package/src/polytool/pt-dialog.ts

@@ -3,11 +3,20 @@ 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 {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
+import {getHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
+import {HelmAtom} from '@datagrok-libraries/bio/src/helm/types';
+
 import {RuleInputs, RULES_PATH, RULES_STORAGE_NAME} from './pt-rules';
 import {addTransformedColumn} from './pt-conversion';
 
 import {handleError} from './utils';
-import {getLibrariesList, HelmInput, getEnumeration} from './pt-enumeration';
+import {defaultErrorHandler} from '../utils/err-info';
+import {getLibrariesList} from './utils';
+import {getEnumerationHelm, PT_HELM_EXAMPLE} from './pt-enumeration-helm';
+import {getEnumerationChem, PT_CHEM_EXAMPLE} from './pt-enumeration-chem';
 
 const PT_ERROR_DATAFRAME = 'No dataframe with macromolecule columns open';
 const PT_WARNING_COLUMN = 'No marcomolecule column chosen!';
@@ -24,15 +33,15 @@ export async function getPolyToolConversionDialog(): Promise<DG.Dialog> {
   if (!targetColumns)
     throw new Error(PT_ERROR_DATAFRAME);
 
-  const targetColumnInput = ui.columnInput(
-    'Column', grok.shell.t, targetColumns[0], null,
-    {filter: (col: DG.Column) => col.semType === DG.SEMTYPE.MACROMOLECULE}
-  );
+  const targetColumnInput = ui.input.column('Column', {
+    table: grok.shell.t, value: targetColumns[0],
+    filter: (col: DG.Column) => col.semType === DG.SEMTYPE.MACROMOLECULE
+  });
 
-  const generateHelmChoiceInput = ui.boolInput(PT_UI_GET_HELM, true);
+  const generateHelmChoiceInput = ui.input.bool(PT_UI_GET_HELM, {value: true});
   ui.tooltip.bind(generateHelmChoiceInput.root, PT_UI_ADD_HELM);
 
-  const chiralityEngineInput = ui.boolInput(PT_UI_USE_CHIRALITY, false);
+  const chiralityEngineInput = ui.input.bool(PT_UI_USE_CHIRALITY, {value: false});
   const ruleInputs = new RuleInputs(RULES_PATH, RULES_STORAGE_NAME, '.json');
   const rulesHeader = ui.inlineText([PT_UI_RULES_USED]);
   ui.tooltip.bind(rulesHeader, 'Add or specify rules to use');
@@ -73,42 +82,122 @@ export async function getPolyToolConversionDialog(): Promise<DG.Dialog> {
   return dialog;
 }
 
-export async function getPolyToolEnumerationDialog(): Promise<DG.Dialog> {
-  const helmInput = await HelmInput.init();
+export async function getPolyToolEnumerationHelmDialog(cell?: DG.Cell): Promise<DG.Dialog> {
+  const [libList, helmHelper] = await Promise.all([
+    getLibrariesList(), getHelmHelper()]);
+
+  const helmValue = cell ? cell.value : PT_HELM_EXAMPLE;
 
-  const libList = await getLibrariesList();
-  const screenLibrary = ui.choiceInput('Library to use', null, libList);
+  const helmInput = helmHelper.createHelmInput('Macromolecule', {value: helmValue});
+  const screenLibrary = ui.input.choice('Library to use', {value: null, items: libList});
 
+  helmInput.input.setAttribute('style', `min-width:250px!important;`);
   screenLibrary.input.setAttribute('style', `min-width:250px!important;`);
 
   const div = ui.div([
-    helmInput.getDiv(),
+    helmInput.root,
     screenLibrary.root
   ]);
 
+  // Displays the molecule from a current cell (monitors changes)
+  const cccSubs = grok.events.onCurrentCellChanged.subscribe(() => {
+    const cell = grok.shell.tv.dataFrame.currentCell;
+
+    if (cell.column.semType === DG.SEMTYPE.MACROMOLECULE && cell.column.meta.units === NOTATION.HELM)
+      helmInput.stringValue = cell.value;
+  });
+
   const dialog = ui.dialog(PT_UI_DIALOG_ENUMERATION)
     .add(div)
     .onOK(async () => {
       try {
-        const helmString = helmInput.getHelmString();
-        const helmSelections = helmInput.getHelmSelections();
+        const helmString = helmInput.stringValue;
+        const helmSelections: number[] = wu.enumerate<HelmAtom>(helmInput.value.atoms)
+          .filter(([a, aI]) => a.highlighted)
+          .map(([a, aI]) => aI).toArray();
         if (helmString === undefined || helmString === '') {
           grok.shell.warning('PolyTool: no molecule was provided');
         } else if (helmSelections === undefined || helmSelections.length < 1) {
           grok.shell.warning('PolyTool: no selection was provided');
         } else {
-          const molecules = await getEnumeration(helmString, helmSelections, screenLibrary.value!);
+          const molecules = await getEnumerationHelm(helmString, helmSelections, screenLibrary.value!);
           const molCol = DG.Column.fromStrings('Enumerated', molecules);
           const df = DG.DataFrame.fromColumns([molCol]);
           grok.shell.addTableView(df);
         }
       } catch (err: any) {
-
+        defaultErrorHandler(err);
       } finally {
-
+        cccSubs.unsubscribe();
       }
     }).onCancel(() => {
+      cccSubs.unsubscribe();
+    });
+
+  return dialog;
+}
+
+export async function getPolyToolEnumerationChemDialog(cell?: DG.Cell): Promise<DG.Dialog> {
+  const [libList, helmHelper] = await Promise.all([
+    getLibrariesList(), getHelmHelper()]);
+
+  let molValue = PT_CHEM_EXAMPLE;//cell ? cell.value : PT_CHEM_EXAMPLE;
+  const molInput = new DG.chem.Sketcher(DG.chem.SKETCHER_MODE.EXTERNAL);
+  molInput.syncCurrentObject = false;
+  // sketcher.setMolFile(col.tags[ALIGN_BY_SCAFFOLD_TAG]);
+  molInput.onChanged.subscribe((_: any) => {
+    molValue = molInput.getMolFile();
+    // col.tags[ALIGN_BY_SCAFFOLD_TAG] = molFile;
+    // col.temp[ALIGN_BY_SCAFFOLD_TAG] = molFile;
+    // col.dataFrame?.fireValuesChanged();
+  });
+  molInput.root.classList.add('ui-input-editor');
+  molInput.root.style.marginTop = '3px';
+  molInput.setMolFile(molValue);
+
+  //const helmInput = helmHelper.createHelmInput('Macromolecule', {value: helmValue});
+  const screenLibrary = ui.input.choice('Library to use', {value: null, items: libList});
+
+  molInput.root.setAttribute('style', `min-width:250px!important;`);
+  molInput.root.setAttribute('style', `max-width:250px!important;`);
+  screenLibrary.input.setAttribute('style', `min-width:250px!important;`);
+
+  const div = ui.div([
+    molInput.root,
+    screenLibrary.root
+  ]);
 
+  const cccSubs = grok.events.onCurrentCellChanged.subscribe(() => {
+    const cell = grok.shell.tv.dataFrame.currentCell;
+
+    if (cell.column.semType === DG.SEMTYPE.MOLECULE)
+      molInput.setValue(cell.value);
+  });
+
+  // Displays the molecule from a current cell (monitors changes)
+  const dialog = ui.dialog(PT_UI_DIALOG_ENUMERATION)
+    .add(div)
+    .onOK(async () => {
+      try {
+        const molString = molInput.getMolFile();
+
+        if (molString === undefined || molString === '') {
+          grok.shell.warning('PolyTool: no molecule was provided');
+        } else if (!molString.includes('R#')) {
+          grok.shell.warning('PolyTool: no R group was provided');
+        } else {
+          const molecules = await getEnumerationChem(molString, screenLibrary.value!);
+          const molCol = DG.Column.fromStrings('Enumerated', molecules);
+          const df = DG.DataFrame.fromColumns([molCol]);
+          grok.shell.addTableView(df);
+        }
+      } catch (err: any) {
+        defaultErrorHandler(err);
+      } finally {
+        cccSubs.unsubscribe();
+      }
+    }).onCancel(() => {
+      cccSubs.unsubscribe();
     });
 
   return dialog;

package/src/polytool/pt-enumeration-chem.ts

@@ -0,0 +1,105 @@
+import * as ui from 'datagrok-api/ui';
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+
+import {getAvailableMonomers, getAvailableMonomerMols} from './utils';
+import {RDModule, RDMol} from '@datagrok-libraries/chem-meta/src/rdkit-api';
+
+export const PT_CHEM_EXAMPLE = `
+
+
+ 22 24  0  0  0  0  0  0  0  0999 V2000
+    0.3128   -0.7509    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
+    0.3128    0.0740    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -0.4054   -1.1623    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -1.1081   -0.7509    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -0.4054    0.4877    0.0000 O   0  0  0  0  0  0  0  0  0  0  0  0
+   -1.1081    0.0740    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -1.8175   -1.1623    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
+    1.0222    0.4877    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -1.8175    0.4877    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -2.5292   -0.7509    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
+    1.0222    1.3127    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
+    1.7227    1.7263    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -0.4054   -1.9896    0.0000 O   0  0  0  0  0  0  0  0  0  0  0  0
+   -2.5292    0.0740    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
+    2.4544    1.3127    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
+    1.7406    0.0740    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
+    1.0222   -1.1623    0.0000 O   0  0  0  0  0  0  0  0  0  0  0  0
+    2.4544    0.4877    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0
+   -1.8175   -1.9896    0.0000 O   0  0  0  0  0  0  0  0  0  0  0  0
+   -3.2453    0.4877    0.0000 O   0  0  0  0  0  0  0  0  0  0  0  0
+    3.1670    1.7285    0.0000 R#  0  0  0  0  0  0  0  0  0  0  0  0
+    1.7149    2.5513    0.0000 R#  0  0  0  0  0  0  0  0  0  0  0  0
+  2  1  2  0  0  0  0
+  3  1  1  0  0  0  0
+  4  3  1  0  0  0  0
+  5  2  1  0  0  0  0
+  6  5  1  0  0  0  0
+  7  4  1  0  0  0  0
+  8  2  1  0  0  0  0
+  9  6  1  0  0  0  0
+ 10  7  2  0  0  0  0
+ 11  8  2  0  0  0  0
+ 12 11  1  0  0  0  0
+ 13  3  2  0  0  0  0
+ 14  9  2  0  0  0  0
+ 15 18  1  0  0  0  0
+ 16  8  1  0  0  0  0
+ 17  1  1  0  0  0  0
+ 18 16  2  0  0  0  0
+ 19  7  1  0  0  0  0
+ 20 14  1  0  0  0  0
+  6  4  2  0  0  0  0
+ 15 12  2  0  0  0  0
+ 14 10  1  0  0  0  0
+ 15 21  1  0  0  0  0
+ 12 22  1  0  0  0  0
+M  RGP  2  21   1  22   2
+M  END`;
+
+export async function getEnumerationChem(molString: string, screenLibrary: string):
+  Promise<string[]> {
+  const variableMonomers = await getAvailableMonomers(screenLibrary);
+  const variableMols = await getAvailableMonomerMols(screenLibrary);
+
+	const idx = molString.indexOf('M  RGP');
+	const rCount = parseInt(molString.slice(idx + 6, idx + 9)); //extracting from molfile positions
+  const size = 1 * variableMonomers.length;
+  const enumerations = new Array<string>(size);
+
+	const rdkitModule: RDModule = await grok.functions.call('Chem:getRdKitModule');
+  const molScaffold: RDMol = rdkitModule.get_mol(molString);
+  const smiScaffold = molScaffold.get_smiles();
+  molScaffold.delete();
+
+  const smilesSubsts = new Array<string>(variableMonomers.length);
+
+  for (let i = 0; i < variableMonomers.length; i++) {
+			
+    const name = variableMonomers[i];
+    const molBlock = variableMols[name];
+    const molSubst: RDMol = rdkitModule.get_mol(molBlock);
+    smilesSubsts[i] = molSubst.get_smiles();
+    molSubst.delete();
+  }
+
+	//TODO: get for all R groups
+  for (let i = 0; i < 1; i++) {
+    for (let j = 0; j < variableMonomers.length; j++) {
+      try {
+        const smiResRaw = `${smiScaffold}.${smilesSubsts[j]}`.replaceAll('[1*]C', 'C([1*])').replaceAll('[1*]c', 'c([1*])').replaceAll('[1*]O', 'O([1*])').replaceAll('[1*]N', 'N([1*])');
+        const smiRes = `${smiResRaw}`.replaceAll('([1*])', '9').replaceAll('[1*]', '9');
+        const molRes: RDMol = rdkitModule.get_mol(smiRes);
+
+        enumerations[i * variableMonomers.length + j] = molRes.get_v3Kmolblock();
+        molRes.delete();
+      } 
+      catch(err:any) {
+        enumerations[i * variableMonomers.length + j] = '';
+      }
+		}
+  }
+
+  return enumerations;
+}

package/src/polytool/pt-enumeration-helm.ts

@@ -0,0 +1,22 @@
+import * as ui from 'datagrok-api/ui';
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+import {Chain} from './pt-conversion';
+import {getAvailableMonomers} from './utils'
+
+export const PT_HELM_EXAMPLE = 'PEPTIDE1{[R].[F].[T].[G].[H].[F].[G].[A].[A].[Y].[P].[E].[NH2]}$$$$';
+
+export async function getEnumerationHelm(helmString: string, helmSelections: number[], screenLibrary: string):
+  Promise<string[]> {
+  const variableMonomers = await getAvailableMonomers(screenLibrary);
+  const chain: Chain = Chain.fromHelm(helmString);
+  const size = helmSelections.length * variableMonomers.length;
+  const enumerations = new Array<string>(size);
+
+  for (let i = 0; i < helmSelections.length; i++) {
+    for (let j = 0; j < variableMonomers.length; j++)
+      enumerations[i * variableMonomers.length + j] = chain.getHelmChanged(helmSelections[i], variableMonomers[j]);
+  }
+
+  return enumerations;
+}

package/src/polytool/pt-ui.ts

@@ -0,0 +1,25 @@
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+import * as ui from 'datagrok-api/ui';
+
+import {getPolyToolEnumerationHelmDialog, getPolyToolEnumerationChemDialog} from './pt-dialog';
+
+export function polyToolEnumerateHelmUI(cell?: DG.Cell): void {
+  getPolyToolEnumerationHelmDialog(cell)
+    .then((dialog) => {
+      dialog.show({resizable: true});
+    })
+    .catch((_err: any) => {
+      grok.shell.warning('To run PolyTool Enumeration, sketch the macromolecule and select monomers to vary');
+    });
+}
+
+export function polyToolEnumerateChemUI(cell?: DG.Cell): void {
+  getPolyToolEnumerationChemDialog(cell)
+    .then((dialog) => {
+      dialog.show({resizable: true});
+    })
+    .catch((_err: any) => {
+      grok.shell.warning('To run PolyTool Enumeration, sketch the molecule and specify the R group to vary');
+    });
+}

package/src/polytool/utils.ts

@@ -2,19 +2,27 @@
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
-import {_package} from '../package';
 
+import {_package} from '../package';
 import {ALPHABET, ALIGNMENT, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {OrgType} from '@datagrok-libraries/bio/src/helm/types';
+
+import {
+  IMonomerLibFileManager, IMonomerLibHelper
+} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+
+declare const org: OrgType;
+const LIB_PATH = 'System:AppData/Bio/monomer-libraries/';
 
 export function _setPeptideColumn(col: DG.Column): void {
   addCommonTags(col);
-  col.setTag('units', NOTATION.SEPARATOR);
+  col.meta.units = NOTATION.SEPARATOR;
   col.setTag('separator', '-');
   // col.setTag('cell.renderer', 'sequence');
 }
 
 function addCommonTags(col: DG.Column<any>) {
-  col.setTag('quality', DG.SEMTYPE.MACROMOLECULE);
+  col.semType = DG.SEMTYPE.MACROMOLECULE;
   col.setTag('aligned', ALIGNMENT.SEQ);
   col.setTag('alphabet', ALPHABET.PT);
 }
@@ -25,3 +33,26 @@ export function handleError(err: any): void {
   grok.shell.error(errMsg);
   _package.logger.error(err.message, undefined, stack);
 }
+
+export async function getAvailableMonomers(screenLibrary: string): Promise<string[]> {
+  const monomerLibHelper: IMonomerLibHelper = await grok.functions.call('Bio:getMonomerLibHelper', {});
+  const monomerLib = await monomerLibHelper.readLibrary(LIB_PATH, screenLibrary);
+  //NOTICE: works with Peptides only
+  return monomerLib.getMonomerSymbolsByType('PEPTIDE');
+}
+
+export async function getAvailableMonomerMols(screenLibrary: string): Promise<{[monomerSymbol: string]: string}> {
+  const monomerLibHelper: IMonomerLibHelper = await grok.functions.call('Bio:getMonomerLibHelper', {});
+  const monomerLib = await monomerLibHelper.readLibrary(LIB_PATH, screenLibrary);
+  const monomers = monomerLib.getMonomerSymbolsByType('PEPTIDE');
+  const mols = new Array<string>(monomers.length);
+
+  //NOTICE: works with Peptides only
+  return monomerLib.getMonomerMolsByPolymerType('PEPTIDE')!;
+}
+
+export async function getLibrariesList(): Promise<string[]> {
+  const monomerLibHelper: IMonomerLibHelper = await grok.functions.call('Bio:getMonomerLibHelper', {});
+  const monomerFileManager: IMonomerLibFileManager = await monomerLibHelper.getFileManager();
+  return monomerFileManager.getValidLibraryPaths();
+}

package/src/utils/context-menu.ts

@@ -0,0 +1,57 @@
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+import * as ui from 'datagrok-api/ui';
+
+import {defaultErrorHandler} from './err-info';
+import {_package, addContextMenu} from '../package';
+import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {polyToolEnumerateHelmUI} from '../polytool/pt-ui';
+
+export type SequenceTranslatorWindowType = Window & {
+  $sequenceTranslator?: {
+    contextMenuError?: any
+  },
+};
+declare const window: SequenceTranslatorWindowType;
+
+export function addContextMenuUI(event: DG.EventData): void {
+  try {
+    const item = event.args.item;
+    if (item) {
+      const menu: DG.Menu = event.args.menu;
+      if (item instanceof DG.GridCell || item.constructor.name == 'GridCell') {
+        const gridCell: DG.GridCell = item;
+        if (addContextMenuForCell(gridCell, menu))
+          event.preventDefault();
+      }
+    }
+  } catch (err: any) {
+    defaultErrorHandler(err);
+    if (!window.$sequenceTranslator) window.$sequenceTranslator = {};
+    window.$sequenceTranslator.contextMenuError = err;
+  }
+}
+
+function addContextMenuForCell(gridCell: DG.GridCell, menu: DG.Menu): boolean {
+  const logPrefix: string = `ST: addContextMenuForCell()`;
+  _package.logger.debug(`${logPrefix}, start`);
+
+  const polyToolEnumerate = () => {
+    polyToolEnumerateHelmUI(gridCell.cell);
+  };
+
+  if (gridCell && gridCell.tableColumn) {
+    switch (gridCell.tableColumn.semType) {
+    case DG.SEMTYPE.MACROMOLECULE: {
+      const sh = SeqHandler.forColumn(gridCell.tableColumn);
+      if (sh.notation === NOTATION.HELM) {
+        menu
+          .item('PolyTool-Enumerate', polyToolEnumerate);
+        true;
+      }
+    }
+    }
+  }
+  return false;
+}

package/src/utils/err-info.ts

@@ -0,0 +1,13 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
+
+import {_package} from '../package';
+
+export function defaultErrorHandler(err: any): void {
+  const [errMsg, errStack] = errInfo(err);
+  _package.logger.error(errMsg, undefined, errStack);
+  grok.shell.error(errMsg);
+}

package/webpack.config.js

@@ -2,9 +2,7 @@ const path = require('path');
 const packageName = path.parse(require('./package.json').name).name.toLowerCase().replace(/-/g, '');
 
 module.exports = {
-  cache: {
-    type: 'filesystem',
-  },
+  cache: {type: 'filesystem'},
   mode: 'development',
   entry: {
     package: ['./src/package.ts'],
@@ -12,7 +10,7 @@ module.exports = {
       filename: 'package-test.js',
       library: {type: 'var', name: `${packageName}_test`},
       import: './src/package-test.ts',
-    }
+    },
   },
   resolve: {
     extensions: ['.ts', '.tsx', '.wasm', '.mjs', '.js', '.json'],

package/src/polytool/pt-enumeration.ts

@@ -1,127 +0,0 @@
-import * as ui from 'datagrok-api/ui';
-import * as grok from 'datagrok-api/grok';
-
-import {IHelmHelper, getHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
-import {IHelmWebEditor} from '@datagrok-libraries/bio/src/helm/types';
-import '@datagrok-libraries/bio/src/types/helm';
-import '@datagrok-libraries/bio/src/types/jsdraw2';
-import * as org from 'org';
-import $ from 'cash-dom';
-import {Unsubscribable, fromEvent} from 'rxjs';
-import {IMonomerLibFileManager, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
-
-import {Chain} from './pt-conversion';
-
-const LIB_PATH = 'System:AppData/Bio/monomer-libraries/';
-const PT_HELM_EXAMPLE = 'PEPTIDE1{[R].[F].[T].[G].[H].[F].[G].[A].[A].[Y].[P].[E].[NH2]}$$$$';
-
-export async function getLibrariesList(): Promise<string[]> {
-  const monomerLibHelper: IMonomerLibHelper = await grok.functions.call('Bio:getMonomerLibHelper', {});
-  const monomerFileManager: IMonomerLibFileManager = await monomerLibHelper.getFileManager();
-  return monomerFileManager.getValidLibraryPaths();
-}
-
-export async function getEnumeration(helmString: string, helmSelections: number[], screenLibrary: string):
-  Promise<string[]> {
-  const variableMonomers = await getAvaialableMonomers(screenLibrary);
-  const chain: Chain = Chain.fromHelm(helmString);
-  const size = helmSelections.length*variableMonomers.length;
-  const enumerations = new Array<string>(size);
-
-  for (let i = 0; i < helmSelections.length; i++) {
-    for (let j = 0; j < variableMonomers.length; j++)
-      enumerations[i*variableMonomers.length + j] = chain.getHelmChanged(helmSelections[i], variableMonomers[j]);
-  }
-
-  return enumerations;
-}
-
-export class HelmInput {
-  webEditorHost: HTMLDivElement | null;
-  webEditorApp: org.helm.IWebEditorApp | null;
-  helmHelper: IHelmHelper;
-  editor: IHelmWebEditor;
-  subs: Unsubscribable[];
-
-  helmString: string = PT_HELM_EXAMPLE;
-  helmSelection: number[];
-
-  constructor(
-    helmHelper: IHelmHelper, editor: IHelmWebEditor) {
-    this.helmHelper = helmHelper;
-    this.editor = editor;
-
-    this.webEditorHost = null;
-    this.webEditorApp = null;
-    const subs: Unsubscribable[] = [];
-
-    subs.push(fromEvent<MouseEvent>(editor.host, 'click').subscribe(() => {
-      this.webEditorHost = ui.div();
-      //TODO: use not hh, but anything from editor.getHelm(true)
-      this.webEditorApp = helmHelper.createWebEditorApp(this.webEditorHost, this.getHelmString());
-      const dlg = ui.dialog({showHeader: false, showFooter: true})
-        .add(this.webEditorHost!)
-        .onOK(() => {
-          try {
-            const webEditorValue = this.webEditorApp!.canvas.getHelm(true)
-              .replace(/<\/span>/g, '').replace(/<span style='background:#bbf;'>/g, '');
-            editor.editor.setHelm(webEditorValue);
-            this.helmString = webEditorValue;
-            this.helmSelection = [];
-
-            //@ts-ignore
-            const selection = this.webEditorApp?.canvas.helm.jsd.m.atoms;
-            for (let i = 0; i < selection.length; i++) {
-              if (selection[i].selected)
-                this.helmSelection.push(i);
-            }
-          } catch (err: any) {
-            //this.logger.error(err);
-          } finally {
-            $(this.webEditorHost).empty();
-            this.webEditorHost = null;
-            this.webEditorApp = null;
-          }
-        })
-        .onCancel(() => {
-          $(this.webEditorHost).empty();
-          this.webEditorHost = null;
-          this.webEditorApp = null;
-        })
-        .show({modal: true, fullScreen: true});
-    }));
-  }
-
-  static async init() {
-    const helmHelper = await getHelmHelper();
-
-    const editor = helmHelper.createHelmWebEditor();
-    editor.host.style.width = '200px';
-    editor.host.style.height = '100px';
-    editor.host.style.paddingLeft = '40px';
-    editor.editor.setHelm(PT_HELM_EXAMPLE);
-
-    return new HelmInput(helmHelper, editor);
-  }
-
-  getHelmString(): string {
-    return this.helmString;
-  }
-
-  getHelmSelections() {
-    return this.helmSelection;
-  }
-
-  getDiv(): HTMLDivElement {
-    const title = ui.divText('Macromolecule', {style: {paddingTop: '43px', color: 'var(--grey-4)'}});
-
-    return ui.divH([title, this.editor.host], {style: {paddingLeft: '48px'}});
-  }
-}
-
-async function getAvaialableMonomers(screenLibrary: string): Promise<string[]> {
-  const monomerLibHelper: IMonomerLibHelper = await grok.functions.call('Bio:getMonomerLibHelper', {});
-  const monomerLib = await monomerLibHelper.readLibrary(LIB_PATH, screenLibrary);
-  //NOTICE: works with Peptides only
-  return monomerLib.getMonomerSymbolsByType('PEPTIDE');
-}