@datagrok/sequence-translator 1.3.11 → 1.3.12

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@datagrok/sequence-translator",
   "friendlyName": "Sequence Translator",
-  "version": "1.3.11",
+  "version": "1.3.12",
   "author": {
     "name": "Alexey Choposky",
     "email": "achopovsky@datagrok.ai"
@@ -22,9 +22,9 @@
     }
   ],
   "dependencies": {
-    "@datagrok-libraries/bio": "5.42.5",
+    "@datagrok-libraries/bio": "5.42.9",
     "@datagrok-libraries/chem-meta": "^1.2.5",
-    "@datagrok-libraries/tutorials": "^1.3.12",
+    "@datagrok-libraries/tutorials": "^1.3.13",
     "@datagrok-libraries/utils": "^4.2.13",
     "@types/react": "^18.0.15",
     "cash-dom": "^8.1.0",
@@ -39,10 +39,11 @@
     "wu": "latest"
   },
   "devDependencies": {
-    "@datagrok-libraries/helm-web-editor": "^1.1.6",
-    "@datagrok-libraries/js-draw-lite": "^0.0.4",
-    "@datagrok/bio": "^2.13.3",
-    "@datagrok/chem": "1.9.2",
+    "@datagrok-libraries/helm-web-editor": "^1.1.8",
+    "@datagrok-libraries/js-draw-lite": "^0.0.6",
+    "@datagrok/bio": "^2.14.2",
+    "@datagrok/helm": "^2.4.1",
+    "@datagrok/chem": "^1.11.3",
     "@types/jquery": "^3.5.14",
     "@types/js-yaml": "^4.0.5",
     "@types/lodash": "^4.14.202",

package/src/apps/common/model/oligo-toolkit-package.ts

@@ -4,6 +4,7 @@ import * as DG from 'datagrok-api/dg';
 
 import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {IMonomerLib, Monomer} from '@datagrok-libraries/bio/src/types';
+import {LoggerWrapper} from '@datagrok-libraries/bio/src/utils/logger';
 
 import {APP_NAME} from '../view/const';
 import {DEFAULT_LIB_FILENAME, FALLBACK_LIB_PATH} from './data-loader/const';
@@ -12,7 +13,6 @@ import {ITranslationHelper} from '../../../types';
 import {SequenceValidator} from './parsing-validation/sequence-validator';
 import {JsonData, loadJsonData} from './data-loader/json-loader';
 import {MonomerLibWrapper} from './monomer-lib/lib-wrapper';
-import {_package} from '../../../package';
 import {FormatConverter} from '../../translator/model/format-converter';
 import {FormatDetector} from './parsing-validation/format-detector';
 import {highlightInvalidSubsequence} from '../view/components/colored-input/input-painters';
@@ -39,8 +39,10 @@ export class OligoToolkitPackage extends DG.Package implements ITranslationHelpe
     return this._monomerLibWrapper;
   }
 
-  constructor() {
+  constructor(opts: { debug: boolean } = {debug: false}) {
     super();
+    // @ts-ignore
+    super._logger = new LoggerWrapper(super.logger, opts.debug);
   }
 
   private initPromise?: Promise<void>;
@@ -51,7 +53,7 @@ export class OligoToolkitPackage extends DG.Package implements ITranslationHelpe
         const packageSettings = await this.getSettings();
         let monomersPath: string = packageSettings['MonomersPath'];
         if (!monomersPath || !(await grok.dapi.files.exists(monomersPath))) {
-          _package.logger.warning(`Monomers path '${monomersPath}' not found. ` +
+          this.logger.warning(`Monomers path '${monomersPath}' not found. ` +
             `Fallback to monomers sample path '${FALLBACK_LIB_PATH}'.`);
           monomersPath = FALLBACK_LIB_PATH;
         }

package/src/package-test.ts

@@ -8,6 +8,7 @@ import './tests/formats-to-helm';
 import './tests/helm-to-nucleotides';
 import './tests/formats-support';
 import './tests/files-tests';
+import './tests/polytool-enumerate-tests';
 
 import {OligoToolkitTestPackage} from './tests/utils';
 

package/src/package.ts

@@ -21,9 +21,9 @@ import {_setPeptideColumn} from './polytool/utils';
 import {PolyToolCsvLibHandler} from './polytool/csv-to-json-monomer-lib-converter';
 import {ITranslationHelper} from './types';
 import {addContextMenuUI} from './utils/context-menu';
-import { NOTATION } from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
 
-export const _package: OligoToolkitPackage = new OligoToolkitPackage();
+export const _package: OligoToolkitPackage = new OligoToolkitPackage(/*{debug: true}/**/);
 
 //name: Oligo Toolkit
 //meta.icon: img/icons/toolkit.png
@@ -169,7 +169,7 @@ export async function polyToolConvert(): Promise<void> {
 //name: polyToolEnumerateHelm
 //description: Perform cyclization of polymers
 export async function polyToolEnumerateHelm(): Promise<void> {
-  polyToolEnumerateHelmUI();
+  await polyToolEnumerateHelmUI();
 }
 
 //top-menu: Bio | Convert | PolyTool-Enumerate Chem
@@ -213,7 +213,7 @@ export function addContextMenu(event: DG.EventData): void {
 // export async function ptConverterApp(): Promise<void> {
 //   const view = grok.shell.v as DG.TableView;
 //   const table = view.dataFrame;
-//   const colNames = table.columns.names(); 
+//   const colNames = table.columns.names();
 //   let covertableName = '';
 
 //   for (let i = 0; i < colNames.length; i++) {
@@ -229,7 +229,7 @@ export function addContextMenu(event: DG.EventData): void {
 //   else {
 //     const dialog = await getPolyToolConversionDialog();
 //     dialog.show();
-//   }  
+//   }
 // }
 
 //name: PolyTool Enumerator Helm
@@ -237,7 +237,7 @@ export function addContextMenu(event: DG.EventData): void {
 //meta.browsePath: PolyTool
 //tags: app
 export async function ptEnumeratorHelmApp(): Promise<void> {
-  polyToolEnumerateHelmUI();
+  await polyToolEnumerateHelmUI();
 }
 
 //name: PolyTool Enumerator Chem
@@ -246,4 +246,4 @@ export async function ptEnumeratorHelmApp(): Promise<void> {
 //tags: app
 export async function ptEnumeratorChemApp(): Promise<void> {
   polyToolEnumerateChemUI();
-}
+}

package/src/polytool/const.ts

@@ -26,3 +26,13 @@ export const R_GROUP_BLOCK_DUMMY = [
     'label': 'R3'
   }
 ];
+
+export const PT_ERROR_DATAFRAME = 'No dataframe with macromolecule columns open';
+export const PT_WARNING_COLUMN = 'No marcomolecule column chosen!';
+
+export const PT_UI_GET_HELM = 'Get HELM';
+export const PT_UI_ADD_HELM = 'Add HELM column';
+export const PT_UI_USE_CHIRALITY = 'Chirality engine';
+export const PT_UI_DIALOG_CONVERSION = 'Poly Tool Conversion';
+export const PT_UI_DIALOG_ENUMERATION = 'Poly Tool Enumeration';
+export const PT_UI_RULES_USED = 'Rules used';

package/src/polytool/pt-conversion.ts

@@ -297,6 +297,7 @@ export async function addTransformedColumn(
     df.columns.add(targetHelmCol);
   }
 
+  // toAtomicLevel
   const molCol = await grok.functions.call('Bio:getMolFromHelm', {
     'df': df,
     'helmCol': targetHelmCol,

package/src/polytool/pt-dialog.ts

@@ -3,11 +3,14 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
+import $ from 'cash-dom';
 import wu from 'wu';
+import {Unsubscribable} from 'rxjs';
 
 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 {HelmAtom, HelmMol} from '@datagrok-libraries/bio/src/helm/types';
+// import {FormsViewer} from '@datagrok-libraries/utils/src/viewers/forms-viewer';
 
 import {RuleInputs, RULES_PATH, RULES_STORAGE_NAME} from './pt-rules';
 import {addTransformedColumn} from './pt-conversion';
@@ -15,27 +18,74 @@ import {addTransformedColumn} from './pt-conversion';
 import {handleError} from './utils';
 import {defaultErrorHandler} from '../utils/err-info';
 import {getLibrariesList} from './utils';
-import {getEnumerationHelm, PT_HELM_EXAMPLE} from './pt-enumeration-helm';
+import {getPtEnumeratorHelm, PT_HELM_EXAMPLE} from './pt-enumeration-helm';
 import {getEnumerationChem, PT_CHEM_EXAMPLE} from './pt-enumeration-chem';
+import {
+  PolyToolEnumeratorParams, PolyToolEnumeratorType, PolyToolEnumeratorTypes, PolyToolPlaceholders
+} from './types';
+
+import {_package} from '../package';
+import {PolyToolPlaceholdersInput} from './pt-placeholders-input';
+import {InputBase} from 'datagrok-api/dg';
+import {PT_ERROR_DATAFRAME, PT_UI_ADD_HELM, PT_UI_DIALOG_CONVERSION, PT_UI_DIALOG_ENUMERATION, PT_UI_GET_HELM, PT_UI_RULES_USED, PT_UI_USE_CHIRALITY, PT_WARNING_COLUMN} from './const';
+import {PolyToolEnumerateDialog} from './pt-enumeration-helm-dialog';
+
+export async function polyToolEnumerateHelmUI(cell?: DG.Cell): Promise<void> {
+  const maxWidth = window.innerWidth;
+  const maxHeight = window.innerHeight;
+
+  try {
+    const resizeInputs = () => {
+      const contentHeight = $(dialog.root).find('div.d4-dialog-contents').get(0)!.clientHeight;
+
+      const fitInputs: { [idx: number]: number } = {1: 1 /*, 3: 0.5*/};
+      const fitInputsSumHeight = Object.values(fitInputs).reduce((sum, h) => sum + h, 0);
+
+      const otherInputsHeight: number = dialog.inputs.filter((input, idx) => !(idx in fitInputs))
+        .map((input) => input.root.offsetHeight).reduce((sum, h) => sum + h, 0);
+      const remainFitHeight = contentHeight - otherInputsHeight - 38;
+      dialog.inputs.forEach((input, idx) => {
+        if (idx in fitInputs) {
+          const inputFitHeight = remainFitHeight * fitInputs[idx] / fitInputsSumHeight;
+          input.root.style.height = `${inputFitHeight}px`;
+        }
+      });
+    };
+    const [dialog, inputs] = await PolyToolEnumerateDialog.create2(cell, resizeInputs);
+
+    let isFirstShow = true;
+    ui.onSizeChanged(dialog.root).subscribe(() => {
+      if (isFirstShow) {
+        const dialogInputList = dialog.inputs;
+        const dialogRootCash = $(dialog.root);
+        const contentMaxHeight = maxHeight
+          - dialogRootCash.find('div.d4-dialog-header').get(0)!.offsetHeight
+          - dialogRootCash.find('div.d4-dialog-footer').get(0)!.offsetHeight;
+
+        // dialog.inputs2.macromolecule.root.style.backgroundColor = '#CCFFCC';
+
+        const dialogWidth = maxWidth * 0.7;
+        const dialogHeight = maxHeight * 0.7;
+
+        // Centered, but resizable dialog
+        dialog.root.style.width = `${Math.min(maxWidth, dialogWidth)}px`;
+        dialog.root.style.height = `${Math.min(maxHeight, dialogHeight)}px`;
+        dialog.root.style.left = `${Math.floor((maxWidth - dialog.root.offsetWidth) / 2)}px`;
+        dialog.root.style.top = `${Math.floor((maxHeight - dialog.root.offsetHeight) / 2)}px`;
+
+        isFirstShow = false;
+      }
 
-const PT_ERROR_DATAFRAME = 'No dataframe with macromolecule columns open';
-const PT_WARNING_COLUMN = 'No marcomolecule column chosen!';
-
-const PT_UI_GET_HELM = 'Get HELM';
-const PT_UI_ADD_HELM = 'Add HELM column';
-const PT_UI_USE_CHIRALITY = 'Chirality engine';
-const PT_UI_DIALOG_CONVERSION = 'Poly Tool Conversion';
-const PT_UI_DIALOG_ENUMERATION = 'Poly Tool Enumeration';
-const PT_UI_RULES_USED = 'Rules used';
-
-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');
+      resizeInputs();
     });
+
+    _package.logger.debug('PolyToolEnumerateHelmUI: dialog before show');
+    const res = dialog.show({width: Math.max(350, maxWidth * 0.7), /* center: true,*/ resizable: true});
+    _package.logger.debug('PolyToolEnumerateHelmUI: dialog after show');
+    const k = 42;
+  } 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 {
@@ -104,61 +154,6 @@ export async function getPolyToolConversionDialog(targetCol?: DG.Column): Promis
   return dialog;
 }
 
-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 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.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.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 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;
-}
-
 async function getPolyToolEnumerationChemDialog(cell?: DG.Cell): Promise<DG.Dialog> {
   const [libList, helmHelper] = await Promise.all([
     getLibrariesList(), getHelmHelper()]);

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

@@ -87,23 +87,8 @@ export async function getEnumerationChem(molString: string, screenLibrary: strin
       //TODO: use RDKit linking function when exposed
       const smiResRaw = `${smiScaffold}.${smilesSubsts[i]}`.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');
-      molRes = rdkitModule.get_mol(smiRes);
+      molRes = rdkitModule.get_mol(smiRes, JSON.stringify({mappedDummiesAreRGroups: true}))
       let molV3 = molRes.get_v3Kmolblock();
-
-
-      //TODO: use RDKit when MASS problem is solved
-      while(molV3.includes('MASS')) {
-
-        //MASS=2 VAL=1
-        //RGROUPS=(1 2)
-        const idx = molV3.indexOf('MASS');
-        const rNum = parseInt(molV3.slice(idx + 5, idx + 6));
-        const replace = `RGROUPS=(1 ${rNum})`;
-        molV3 = molV3.substring(0, idx) + replace + molV3.substring(idx + 12);
-      }
-
-      molV3 = molV3.replaceAll('R ', 'R# ')
-
       enumerations[i] = molV3;
     } 
     catch(err:any) {

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

@@ -0,0 +1,218 @@
+import * as ui from 'datagrok-api/ui';
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+
+import wu from 'wu';
+import {Unsubscribable} from 'rxjs';
+
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {HelmAtom, HelmMol} from '@datagrok-libraries/helm-web-editor/src/types/org-helm';
+import {getHelmHelper, HelmInputBase} from '@datagrok-libraries/bio/src/helm/helm-helper';
+
+import {
+  PolyToolEnumeratorParams, PolyToolEnumeratorType, PolyToolEnumeratorTypes, PolyToolPlaceholders
+} from './types';
+
+import {PT_UI_DIALOG_ENUMERATION} from './const';
+import {getLibrariesList} from './utils';
+import {getPtEnumeratorHelm, PT_HELM_EXAMPLE} from './pt-enumeration-helm';
+import {PolyToolPlaceholdersInput} from './pt-placeholders-input';
+import {Dialog} from 'datagrok-api/dg';
+import {defaultErrorHandler} from '../utils/err-info';
+
+import {_package} from '../package';
+
+type PolyToolEnumerateInputs = {
+  enumeratorType: DG.ChoiceInput<PolyToolEnumeratorType>
+  macromolecule: HelmInputBase;
+  placeholders: PolyToolPlaceholdersInput;
+  toAtomicLevel: DG.InputBase<boolean>;
+};
+
+
+export class PolyToolEnumerateDialog extends DG.Dialog {
+  protected constructor(
+    // public readonly inputs2: PolyToolEnumerateInputs
+  ) {
+    const dlg = ui.dialog({title: PT_UI_DIALOG_ENUMERATION});
+    super(dlg.dart);
+
+    // for (const [key, value] of Object.entries(this.inputs2)) { this.add(value); }
+  }
+
+  public override show(options?: { modal?: boolean; resizable?: boolean; fullScreen?: boolean; center?: boolean; centerAt?: Element; x?: number; y?: number; width?: number; height?: number; backgroundColor?: string; showNextTo?: HTMLElement }): Dialog {
+    return super.show(options);
+  }
+
+  public static async create2(cell?: DG.Cell, resizeInputs?: () => void): Promise<[PolyToolEnumerateDialog, PolyToolEnumerateInputs]> {
+    const logPrefix = `ST: PT: HelmDialog()`;
+
+    const [libList, helmHelper] = await Promise.all([getLibrariesList(), getHelmHelper()]);
+
+    const helmValue = cell ? cell.value : PT_HELM_EXAMPLE;
+    const posDf = DG.DataFrame.fromObjects([{Position: '', Monomers: ''}, {Position: '', Monomers: ''}]);
+
+    const macromoleculeInput = helmHelper.createHelmInput(
+      'Macromolecule', {value: helmValue, editable: false});
+
+    const inputs: PolyToolEnumerateInputs = {
+      enumeratorType: ui.input.choice<PolyToolEnumeratorType>(
+        'Enumerator type', {
+          value: PolyToolEnumeratorTypes.Single,
+          items: Object.values(PolyToolEnumeratorTypes)
+        }) as DG.ChoiceInput<PolyToolEnumeratorType>,
+      macromolecule: macromoleculeInput,
+
+      placeholders: await PolyToolPlaceholdersInput.create(
+        'Placeholders', posDf, {
+          showAddNewRowIcon: true,
+          showRemoveRowIcon: true,
+          showRowHeader: false,
+          showCellTooltip: false,
+        }/*, 2/**/),
+
+      toAtomicLevel: ui.input.bool(
+        'To atomic level', {value: true}),
+    };
+
+    const subs: Unsubscribable[] = [];
+    const destroy = () => { for (const sub of subs) sub.unsubscribe(); };
+
+    subs.push(inputs.macromolecule.onMouseMove.subscribe((e: MouseEvent) => {
+      try {
+        _package.logger.debug(`${logPrefix}, placeholdersInput.onMouseMove()`);
+
+        const argsX = e.offsetX;
+        const argsY = e.offsetY;
+        const mol = inputs.macromolecule.molValue;
+        const hoveredAtom = helmHelper.getHoveredAtom(argsX, argsY, mol, inputs.macromolecule.root.clientHeight);
+        if (hoveredAtom) {
+          const hoveredAtomContIdx = hoveredAtom._parent.atoms.indexOf(hoveredAtom);
+          const hoveredAtomContIdxStr = (hoveredAtomContIdx + 1).toString();
+          const substitutingMonomers = inputs.placeholders.placeholdersValue[hoveredAtomContIdx];
+
+          if (substitutingMonomers) {
+            const cnt = ui.divText(substitutingMonomers.join(', '));
+            inputs.macromolecule.showTooltip(cnt, hoveredAtom);
+            e.preventDefault();
+            e.stopPropagation();
+          }
+        }
+      } catch (err: any) {
+        defaultErrorHandler(err, false);
+      }
+    }));
+    subs.push(inputs.macromolecule.onClick.subscribe((e: MouseEvent) => {
+      try {
+        _package.logger.debug(`${logPrefix}, placeholdersInput.onClick()`);
+
+        const argsX = e.offsetX;
+        const argsY = e.offsetY;
+        const mol = inputs.macromolecule.molValue;
+        const clickedAtom = helmHelper.getHoveredAtom(argsX, argsY, mol, inputs.macromolecule.root.clientHeight);
+        if (clickedAtom) {
+          const clickedAtomContIdx = clickedAtom._parent.atoms.indexOf(clickedAtom);
+          const clickedAtomContIdxStr = (clickedAtomContIdx + 1).toString();
+
+          const phDf = inputs.placeholders.grid.dataFrame;
+          const posList = phDf.columns.byName('Position').toList();
+          let rowIdx = posList.indexOf(clickedAtomContIdxStr);
+          if (rowIdx === -1) {
+            rowIdx = posList.findIndex((v) => isNaN(v));
+            if (rowIdx === -1)
+              rowIdx = phDf.rows.addNew([clickedAtomContIdxStr, '']).idx;
+            phDf.set('Position', rowIdx, clickedAtomContIdxStr);
+            // const tgtCell = inputs.placeholders.grid.cell('Monomers', rowIdx);
+          }
+          phDf.currentCell = phDf.cell(rowIdx, 'Monomers');
+          //const gridRowIdx = inputs.placeholders.grid.tableRowToGrid(rowIdx);
+          //const monomersGCell = inputs.placeholders.grid.cell('Monomers', gridRowIdx);
+          const k = 42;
+        }
+      } catch (err: any) {
+        defaultErrorHandler(err);
+      }
+    }));
+    subs.push(inputs.placeholders.grid.dataFrame.onDataChanged.subscribe(() => {
+      updateMolView();
+    }));
+
+
+    // TODO: suspect
+    subs.push(ui.onSizeChanged(inputs.placeholders.root).subscribe(() => {
+      if (resizeInputs) resizeInputs();
+    }));
+
+    // Displays the molecule from a current cell (monitors changes)
+    subs.push(grok.events.onCurrentCellChanged.subscribe(() => {
+      const cell = grok.shell.tv.dataFrame.currentCell;
+
+      if (cell.column.semType === DG.SEMTYPE.MACROMOLECULE && cell.column.meta.units === NOTATION.HELM)
+        inputs.macromolecule.stringValue = cell.value;
+    }));
+
+    inputs.macromolecule.root.style.setProperty('min-width', '250px', 'important');
+    // inputs.macromolecule.root.style.setProperty('max-height', '300px', 'important');
+
+    const updateMolView = () => {
+      const mol = inputs.macromolecule.molValue;
+      for (let aI = 0; aI < mol.atoms.length; aI++) {
+        const a = mol.atoms[aI];
+        a.highlighted = aI in inputs.placeholders.placeholdersValue;
+        inputs.macromolecule.redraw();
+      }
+    };
+
+    const dialog = new PolyToolEnumerateDialog()
+      .add(inputs.enumeratorType)
+      .add(inputs.macromolecule)
+      .add(inputs.placeholders)
+      .add(inputs.toAtomicLevel)
+      .onOK(async () => {
+        try {
+          const helmString = inputs.macromolecule.stringValue;
+          const helmSelections: number[] = wu.enumerate<HelmAtom>(inputs.macromolecule.molValue.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 /**/ {
+            await getHelmHelper(); // initializes JSDraw and org
+
+            const params: PolyToolEnumeratorParams = {
+              type: inputs.enumeratorType.value!,
+              placeholders: inputs.placeholders.placeholdersValue,
+            };
+            if (Object.keys(params.placeholders).length === 0) {
+              grok.shell.warning(`${PT_UI_DIALOG_ENUMERATION}: placeholders are empty`);
+              return;
+            }
+
+            const enumHelmList = getPtEnumeratorHelm(helmString, params);
+            const enumHelmCol = DG.Column.fromStrings('Enumerated', enumHelmList);
+            const enumeratorResDf = DG.DataFrame.fromColumns([enumHelmCol]);
+
+            if (inputs.toAtomicLevel.value) {
+              const enumMolCol = await grok.functions.call('Bio:getMolFromHelm', {
+                'df': enumeratorResDf,
+                'helmCol': enumHelmCol,
+                'chiralityEngine': true,
+              });
+              enumMolCol.name = enumeratorResDf.columns.getUnusedName(`molfile(${enumHelmCol.name})`);
+              enumMolCol.semType = DG.SEMTYPE.MOLECULE;
+              enumeratorResDf.columns.add(enumMolCol, true);
+            }
+            grok.shell.addTableView(enumeratorResDf);
+          }
+        } catch (err: any) {
+          defaultErrorHandler(err);
+        } finally {
+          destroy();
+        }
+      })
+      .onCancel(() => { destroy(); }) as PolyToolEnumerateDialog;
+    return [dialog, inputs];
+  }
+}

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

@@ -1,22 +1,74 @@
 import * as ui from 'datagrok-api/ui';
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
+
+import {HelmType, JSDraw2ModuleType, OrgType, HelmAtom, HelmMol} from '@datagrok-libraries/bio/src/helm/types';
+
 import {Chain} from './pt-conversion';
-import {getAvailableMonomers} from './utils'
+import {getAvailableMonomers} from './utils';
+import {PolyToolEnumeratorParams, PolyToolEnumeratorTypes, PolyToolPlaceholders} from './types';
 
 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);
+/** Initialized by getHelmHelper via init Helm package */
+declare const JSDraw2: JSDraw2ModuleType;
+declare const org: OrgType;
 
-  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]);
+function polyToolEnumeratorCore(m: HelmMol, position: number, monomerList: string[]): HelmMol[] {
+  const resMolList: HelmMol[] = new Array<HelmMol>(monomerList.length);
+  for (let i = 0; i < monomerList.length; i++) {
+    const symbolName = monomerList[i];
+    const resM = resMolList[i] = m.clone();
+    resM.atoms[position].elem = symbolName;
   }
+  return resMolList;
+}
+
+/**
+ * @param {string} helm Molecule string Helm format
+ * @param  placeholders Placeholders by zero-based position key
+ * @returns {string[]} List of enumerated molecules in Helm format
+ */
+function getPtEnumeratorSingle(helm: string, placeholders: PolyToolPlaceholders): string[] {
+  const molHandler = new JSDraw2.MolHandler<HelmType>();
+  const plugin = new org.helm.webeditor.Plugin(molHandler);
+  const io = org.helm.webeditor.IO;
+
+  const origin = new JSDraw2.Point(0, 0);
+  io.parseHelm(plugin, helm, origin, undefined);
+
+  const coreResList: HelmMol[][] = Object.entries(placeholders)
+    .map(([p, monomerList]: [string, string[]]) => polyToolEnumeratorCore(molHandler.m, parseInt(p), monomerList));
+  const resMolList = coreResList.reduce((acc, posList) => acc.concat(posList), []);
+
+  const resHelmList = resMolList.map((m: HelmMol) => org.helm.webeditor.IO.getHelm(m)!);
+  return resHelmList;
+}
 
-  return enumerations;
+function getPtEnumeratorMatrix(helm: string, placeholders: PolyToolPlaceholders): string[] {
+  const molHandler = new JSDraw2.MolHandler<HelmType>();
+  const plugin = new org.helm.webeditor.Plugin(molHandler);
+  const io = org.helm.webeditor.IO;
+
+  const origin = new JSDraw2.Point(0, 0);
+  io.parseHelm(plugin, helm, origin, undefined);
+
+  let resMolList = [molHandler.m];
+  for (const [p, monomerList] of Object.entries(placeholders)) {
+    const pos: number = parseInt(p);
+    const posResMolList: HelmMol[][] = resMolList.map((m: HelmMol) => polyToolEnumeratorCore(m, pos, monomerList));
+    resMolList = posResMolList.reduce((acc, l) => acc.concat(l), []);
+  }
+
+  const resHelmList = resMolList.map((m: HelmMol) => org.helm.webeditor.IO.getHelm(m)!);
+  return resHelmList;
+}
+
+export function getPtEnumeratorHelm(helm: string, params: PolyToolEnumeratorParams): string[] {
+  switch (params.type) {
+  case PolyToolEnumeratorTypes.Single:
+    return getPtEnumeratorSingle(helm, params.placeholders);
+  case PolyToolEnumeratorTypes.Matrix:
+    return getPtEnumeratorMatrix(helm, params.placeholders);
+  }
 }