@datagrok/sequence-translator 1.4.7 → 1.4.10

package/src/polytool/{pt-enumeration-helm-dialog.ts → pt-enumerate-seq-dialog.ts}

@@ -4,8 +4,9 @@ import * as DG from 'datagrok-api/dg';
 
 import $ from 'cash-dom';
 import wu from 'wu';
-import {fromEvent, Unsubscribable} from 'rxjs';
-import {HelmAtom} from '@datagrok-libraries/helm-web-editor/src/types/org-helm';
+import {Unsubscribable} from 'rxjs';
+
+import {GetMonomerResType, HelmAtom, MonomerNumberingTypes} from '@datagrok-libraries/helm-web-editor/src/types/org-helm';
 import {getHelmHelper, HelmInputBase, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 import {getMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {HelmType, PolymerType} from '@datagrok-libraries/bio/src/helm/types';
@@ -14,6 +15,8 @@ import {getSeqHelper, ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-he
 import '@datagrok-libraries/bio/src/types/input';
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
 import {InputColumnBase} from '@datagrok-libraries/bio/src/types/input';
+import {SeqValueBase} from '@datagrok-libraries/bio/src/utils/macromolecule/seq-handler';
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
 import {PolyToolEnumeratorParams, PolyToolEnumeratorType, PolyToolEnumeratorTypes} from './types';
 import {getLibrariesList} from './utils';
@@ -21,11 +24,18 @@ import {doPolyToolEnumerateHelm, PT_HELM_EXAMPLE} from './pt-enumeration-helm';
 import {PolyToolPlaceholdersInput} from './pt-placeholders-input';
 import {defaultErrorHandler} from '../utils/err-info';
 import {PolyToolPlaceholdersBreadthInput} from './pt-placeholders-breadth-input';
-import {PT_UI_DIALOG_ENUMERATION} from './const';
+import {PT_UI_DIALOG_ENUMERATION, PT_UI_GET_HELM, PT_UI_HIGHLIGHT_MONOMERS, PT_UI_RULES_USED, PT_UI_USE_CHIRALITY} from './const';
 import {PolyToolDataRole, PolyToolTags} from '../consts';
-import {Chain} from './pt-conversion';
+import {RuleInputs, RULES_PATH, RULES_STORAGE_NAME} from './pt-rules';
+import {Chain} from './conversion/pt-chain';
+import {polyToolConvert} from './pt-dialog';
 
 import {_package, applyNotationProviderForCyclized} from '../package';
+import {getUnusedColName} from '@datagrok-libraries/bio/src/monomer-works/utils';
+import {buildMonomerHoverLink} from '@datagrok-libraries/bio/src/monomer-works/monomer-hover';
+import {MmcrTemps} from '@datagrok-libraries/bio/src/utils/cell-renderer-consts';
+import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
+import {PolymerTypes} from '@datagrok-libraries/bio/src/helm/consts';
 
 type PolyToolEnumerateInputs = {
   macromolecule: HelmInputBase;
@@ -35,7 +45,10 @@ type PolyToolEnumerateInputs = {
   trivialNameCol: InputColumnBase,
   keepOriginal: DG.InputBase<boolean>;
   toAtomicLevel: DG.InputBase<boolean>;
-  toHarmonizedSequence: DG.InputBase<boolean>;
+  generateHelm: DG.InputBase<boolean>;
+  chiralityEngine: DG.InputBase<boolean>;
+  highlightMonomers: DG.InputBase<boolean>;
+  rules: { header: HTMLElement, form: HTMLDivElement },
 };
 
 type PolyToolEnumerateHelmSerialized = {
@@ -46,7 +59,10 @@ type PolyToolEnumerateHelmSerialized = {
   trivialNameCol: string;
   keepOriginal: boolean;
   toAtomicLevel: boolean;
-  toHarmonizedSequence: boolean;
+  generateHelm: boolean;
+  chiralityEngine: boolean;
+  highlightMonomers: boolean;
+  rules: string[],
 };
 
 export async function polyToolEnumerateHelmUI(cell?: DG.Cell): Promise<void> {
@@ -72,26 +88,24 @@ export async function polyToolEnumerateHelmUI(cell?: DG.Cell): Promise<void> {
         .filter((el) => el instanceof HTMLElement)
         .map((el) => (el as HTMLElement).offsetHeight).reduce((sum, h) => sum + h, 0);
       const remainFitHeight = contentHeight - otherInputsHeight - 38;
-      dialog.inputs.forEach((input, idx) => {
+      for (const idx of wu.count(0).take(dialogContentEl.children.length)) {
         if (idx in fitInputs) {
+          const el = dialogContentEl.children[idx] as HTMLElement;
           const inputFitHeight = remainFitHeight * fitInputs[idx] / fitInputsSumHeight;
-          input.root.style.height = `${inputFitHeight}px`;
+          el.style.height = `${inputFitHeight}px`;
         }
-      });
+      }
     };
     dialog = await getPolyToolEnumerateDialog(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;
 
@@ -113,7 +127,7 @@ export async function polyToolEnumerateHelmUI(cell?: DG.Cell): Promise<void> {
     _package.logger.debug('PolyToolEnumerateHelmUI: dialog after show');
   } catch (err: any) {
     const [errMsg, errStack] = errInfo(err);
-    grok.shell.warning('To run PolyTool Enumeration, sketch the macromolecule and select monomers to vary');
+    //grok.shell.warning('To run PolyTool Enumeration, sketch the macromolecule and select monomers to vary');
     _package.logger.error(errMsg, undefined, errStack);
   }
 }
@@ -129,18 +143,56 @@ async function getPolyToolEnumerateDialog(
     inputs.placeholders.detach();
   };
   try {
-    const monomerLib = (await getMonomerLibHelper()).getMonomerLib();
+    const libHelper = await getMonomerLibHelper();
+    const monomerLib = libHelper.getMonomerLib();
     const seqHelper = await getSeqHelper();
     const emptyDf: DG.DataFrame = DG.DataFrame.fromColumns([]);
 
     const [libList, helmHelper] = await Promise.all([getLibrariesList(), getHelmHelper()]);
+    const monomerLibFuncs = helmHelper.buildMonomersFuncsFromLib(monomerLib);
+
+    const getValue = (cell?: DG.Cell): [SeqValueBase, PolyToolDataRole] => {
+      let resSeqValue: SeqValueBase;
+      let resDataRole: PolyToolDataRole;
+      if (cell && cell.rowIndex >= 0 && cell?.column.semType == DG.SEMTYPE.MACROMOLECULE) {
+        const sh = seqHelper.getSeqHandler(cell.column);
+        resSeqValue = sh.getValue(cell.rowIndex);
+        resDataRole = (resSeqValue.tags[PolyToolTags.dataRole] as PolyToolDataRole.template) ?? PolyToolDataRole.macromolecule;
+      } else {
+        const seqCol = DG.Column.fromList(DG.COLUMN_TYPE.STRING, 'seq', [PT_HELM_EXAMPLE]);
+        seqCol.meta.units = NOTATION.HELM;
+        const sh = seqHelper.getSeqHandler(seqCol);
+        resSeqValue = sh.getValue(0);
+        resDataRole = PolyToolDataRole.macromolecule;
+      }
+      return [resSeqValue, resDataRole];
+    };
+
+    let [seqValue, dataRole]: [SeqValueBase, PolyToolDataRole] = getValue(cell);
 
     let srcId: { value: string, colName: string } | null = null;
+    let ruleFileList: string[];
+    let ruleInputs: RuleInputs;
     const trivialNameSampleDiv = ui.divText('', {style: {marginLeft: '8px', marginTop: '2px'}});
     const warningsTextDiv = ui.divText('', {style: {color: 'red'}});
     inputs = {
       macromolecule: helmHelper.createHelmInput(
-        'Macromolecule', {editable: false}),
+        'Macromolecule', {
+          editable: false,
+          editorOptions: {
+            drawOptions: {
+              monomerNumbering: MonomerNumberingTypes.continuous,
+              getMonomer: (a: HelmAtom | HelmType, name?: string): GetMonomerResType => {
+                const aa: HelmAtom = a as HelmAtom;
+                if (aa.T === 'ATOM') {
+                  const canonicalSymbol = seqValue.getSplitted().getCanonical(aa.bio!.continuousId - 1);
+                  return monomerLibFuncs.getMonomer(aa.bio!.type, canonicalSymbol);
+                } else
+                  return monomerLibFuncs.getMonomer(a, name);
+              },
+            },
+          }
+        }),
       placeholders: await PolyToolPlaceholdersInput.create(
         'Placeholders', {
           showAddNewRowIcon: true,
@@ -163,9 +215,19 @@ async function getPolyToolEnumerateDialog(
       keepOriginal: ui.input.bool(
         'Keep original', {value: false}),
       toAtomicLevel: ui.input.bool(
-        'To atomic level', {value: false}),
-      toHarmonizedSequence: ui.input.bool(
-        'To harmonized sequence', {value: false}),
+        'To atomic level', {
+          value: false,
+          onValueChanged: (value, input) => { updateViewRules(); }
+        }),
+      generateHelm: ui.input.bool(PT_UI_GET_HELM, {value: true}),
+      chiralityEngine: ui.input.bool(PT_UI_USE_CHIRALITY, {value: false}),
+      highlightMonomers: ui.input.bool(PT_UI_HIGHLIGHT_MONOMERS, {value: false}),
+      rules: {
+        header: ui.inlineText([PT_UI_RULES_USED]),
+        form: await (ruleInputs = new RuleInputs(RULES_PATH, RULES_STORAGE_NAME, '.json', {
+          onValueChanged: (value: string[]) => { ruleFileList = value; }
+        })).getForm()
+      },
       trivialNameCol: ui.input.column2(
         'Trivial name', {
           table: cell?.dataFrame,
@@ -186,28 +248,33 @@ async function getPolyToolEnumerateDialog(
         }),
     };
 
-    inputs.toHarmonizedSequence.root.style.display = 'none';
     inputs.trivialNameCol.addOptions(trivialNameSampleDiv);
 
     let placeholdersValidity: string | null = null;
     inputs.placeholders.addValidator((value: string): string | null => {
       const errors: string[] = [];
       try {
+        if (dataRole !== PolyToolDataRole.macromolecule)
+          return null;
+
         const missedMonomerList: { polymerType: PolymerType, symbol: string }[] = [];
         for (const ph of inputs.placeholders.placeholdersValue) {
           const pos = ph.position;
+          if (pos == null)
+            continue;
           if (pos >= inputs.macromolecule.molValue.atoms.length) {
             errors.push(`There is no monomer at position ${pos + 1}.`);
             continue;
           }
           const a = inputs.macromolecule.molValue.atoms[pos];
-          const helmType: HelmType = a.biotype()!;
-          const polymerType = helmTypeToPolymerType(helmType);
-          for (const symbol of ph.monomers) {
-            const substituteMonomer = monomerLib.getMonomer(polymerType, symbol)!;
-            // TODO: Check substitution monomer is presented in the library
-            if (!substituteMonomer || !substituteMonomer.lib)
-              missedMonomerList.push({polymerType, symbol});
+          if (a) {
+            const helmType: HelmType = a.biotype()!;
+            const polymerType = helmTypeToPolymerType(helmType);
+            for (const symbol of ph.monomers) {
+              const substituteMonomer = monomerLib.getMonomer(polymerType, symbol)!;
+              if (!substituteMonomer || !substituteMonomer.lib)
+                missedMonomerList.push({polymerType, symbol});
+            }
           }
         }
 
@@ -231,6 +298,57 @@ async function getPolyToolEnumerateDialog(
       return placeholdersValidity;
     });
 
+    // inputs.placeholdersBreadth.addValidator((value: string): string | null => {
+    //   const errors: string[] = [];
+    //   try {
+    //     if (dataRole !== PolyToolDataRole.macromolecule)
+    //       return null;
+    //
+    //     const missedMonomerList: { polymerType: PolymerType, symbol: string }[] = [];
+    //     for (const ph of inputs.placeholdersBreadth.placeholdersBreadthValue) {
+    //       const posErrors = [];
+    //       if (ph.start == null || ph.end == null)
+    //         continue;
+    //       if (ph.start < 0)
+    //         posErrors.push(`There is no monomer at start position ${ph.start + 1}.`);
+    //       if (ph.start >= inputs.macromolecule.molValue.atoms.length)
+    //         posErrors.push(`There is no monomer at start position ${ph.start + 1}.`);
+    //       if (ph.end < 0)
+    //         posErrors.push(`There is no monomer at end position ${ph.end + 1}.`);
+    //       if (ph.end >= inputs.macromolecule.molValue.atoms.length)
+    //         posErrors.push(`There is no monomer at end position ${ph.end + 1}.`);
+    //       errors.push(...posErrors);
+    //       if (posErrors.length > 0)
+    //         continue;
+    //
+    //       const polymerType = PolymerTypes.PEPTIDE;
+    //       for (const symbol of ph.monomers) {
+    //         const substituteMonomer = monomerLib.getMonomer(null, symbol)!;
+    //         if (!substituteMonomer || !substituteMonomer.lib)
+    //           missedMonomerList.push({polymerType, symbol});
+    //       }
+    //
+    //       const byType: { [polymerType: string]: string[] } = {};
+    //       for (const sm of missedMonomerList) {
+    //         let byTypeList = byType[sm.polymerType];
+    //         if (!byTypeList) byTypeList = byType[sm.polymerType] = [];
+    //         byTypeList.push(sm.symbol);
+    //       }
+    //       const byTypeStr: string = Object.entries(byType)
+    //         .map(([polymerType, symbolList]) => `${polymerType}: ${symbolList.join(', ')}`)
+    //         .join('\n');
+    //       if (Object.keys(byTypeStr).length > 0)
+    //         errors.push(`Placeholders contain missed monomers: ${byTypeStr}`);
+    //       placeholdersValidity = errors.length > 0 ? errors.join('\n') : null;
+    //     }
+    //   } catch (err: any) {
+    //     const [errMsg, errStack] = defaultErrorHandler(err, false);
+    //     placeholdersValidity = errMsg;
+    //   }
+    //   setTimeout(() => { updateWarnings(); }, 0);
+    //   return placeholdersValidity;
+    // });
+
     subs.push(inputs.macromolecule.onMouseMove.subscribe((e: MouseEvent) => {
       try {
         _package.logger.debug(`${logPrefix}, placeholdersInput.onMouseMove()`);
@@ -265,39 +383,19 @@ async function getPolyToolEnumerateDialog(
         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;
+          const clickedAtomContIdxStr = String(clickedAtomContIdx + 1);
+          inputs.placeholders.addPosition(clickedAtomContIdx);
         }
       } catch (err: any) {
         defaultErrorHandler(err);
       }
     }));
-    subs.push(inputs.placeholders.grid.dataFrame.onDataChanged.subscribe(() => {
-      updateMolView();
-    }));
-    subs.push(fromEvent<KeyboardEvent>(inputs.placeholders.grid.root, 'keydown')
-      .subscribe((e: KeyboardEvent) => {
-        if (e.key === 'Enter') e.stopPropagation();
-      }));
+    subs.push(inputs.placeholders.onChanged.subscribe(() => { updateViewMol(); }));
 
     // TODO: suspect
     subs.push(ui.onSizeChanged(inputs.placeholders.root).subscribe(() => {
-      if (resizeInputs) resizeInputs();
+      if (resizeInputs)
+        resizeInputs();
     }));
 
     // Displays the molecule from a current cell (monitors changes)
@@ -305,14 +403,15 @@ async function getPolyToolEnumerateDialog(
       const cell = grok.shell.tv.dataFrame.currentCell;
       if (cell.column.semType !== DG.SEMTYPE.MACROMOLECULE) return;
 
-      fillForCurrentCell(cell);
+      [seqValue, dataRole] = getValue();
+      fillForCurrentCell(seqValue, dataRole, cell);
     }));
 
     inputs.macromolecule.root.style.setProperty('min-width', '250px', 'important');
     // inputs.macromolecule.root.style.setProperty('max-height', '300px', 'important');
 
-    const phPosSet = new Set<number>(inputs.placeholders.placeholdersValue.map((ph) => ph.position));
-    const updateMolView = () => {
+    const updateViewMol = () => {
+      const phPosSet = new Set<number>(inputs.placeholders.placeholdersValue.map((ph) => ph.position));
       const mol = inputs.macromolecule.molValue;
       for (let aI = 0; aI < mol.atoms.length; aI++) {
         const a = mol.atoms[aI];
@@ -321,6 +420,22 @@ async function getPolyToolEnumerateDialog(
       inputs.macromolecule.redraw();
     };
 
+    const updateViewRules = () => {
+      if (inputs.toAtomicLevel.value && dataRole === PolyToolDataRole.template) {
+        inputs.generateHelm.root.style.removeProperty('display');
+        inputs.chiralityEngine.root.style.removeProperty('display');
+        inputs.highlightMonomers.root.style.removeProperty('display');
+        inputs.rules.header.style.removeProperty('display');
+        inputs.rules.form.style.removeProperty('display');
+      } else {
+        inputs.generateHelm.root.style.display = inputs.chiralityEngine.root.style.display =
+          inputs.highlightMonomers.root.style.display = 'none';
+        inputs.rules.header.style.display = inputs.rules.form.style.display = 'none';
+      }
+      if (resizeInputs)
+        resizeInputs();
+    };
+
     const updateWarnings = () => {
       const warnings = placeholdersValidity;
       // const iw = inputs.warnings;
@@ -344,15 +459,6 @@ async function getPolyToolEnumerateDialog(
     };
 
     const fillTrivialNameList = (table?: DG.DataFrame) => {
-      // const colList: DG.Column[] = [];
-      // const colCount: number = cell.dataFrame.columns.length;
-      //
-      // // TODO: by semType?
-      // for (let colI: number = 0; colI < colCount; ++colI) {
-      //   const col = cell.dataFrame.columns.byIndex(colI);
-      //   if (col.type === DG.COLUMN_TYPE.STRING) colList.push(col);
-      // }
-
       if (table) {
         inputs.trivialNameCol.setColumnInputTable(table);
         inputs.trivialNameCol.root.style.removeProperty('display');
@@ -360,36 +466,18 @@ async function getPolyToolEnumerateDialog(
         inputs.trivialNameCol.setColumnInputTable(emptyDf);
         inputs.trivialNameCol.root.style.setProperty('display', 'none');
       }
-      if (resizeInputs) resizeInputs();
+      if (resizeInputs)
+        resizeInputs();
     };
 
-    const fillForCurrentCell = async (cell?: DG.Cell): Promise<PolyToolDataRole> => {
-      let resDataRole;
-      let helmValue: string;
-      let table: DG.DataFrame | undefined = undefined;
-      if (cell && cell.rowIndex >= 0 && cell?.column.semType == DG.SEMTYPE.MACROMOLECULE) {
-        const sh = _package.seqHelper.getSeqHandler(cell.column);
-        const mValue = await sh.getValue(cell.rowIndex);
-        helmValue = mValue.value;
-        table = cell.dataFrame;
-        resDataRole = (mValue.tags[PolyToolTags.dataRole] as PolyToolDataRole.template) ?? PolyToolDataRole.macromolecule;
-      } else {
-        helmValue = PT_HELM_EXAMPLE;
-        resDataRole = PolyToolDataRole.macromolecule;
-      }
-      inputs.macromolecule.stringValue = helmValue;
-
-      if (resDataRole === PolyToolDataRole.template) {
-        inputs.toAtomicLevel.root.style.display = 'none';
-      } else {
-        inputs.toAtomicLevel.root.style.removeProperty('display');
-      }
-
+    const fillForCurrentCell = (mmValue: SeqValueBase, dataRole: PolyToolDataRole, cell?: DG.Cell): void => {
+      inputs.macromolecule.value = mmValue;
+      const table: DG.DataFrame | undefined = cell?.dataFrame;
       fillTrivialNameList(table);
-      return resDataRole;
     };
 
-    let dataRole: PolyToolDataRole = await fillForCurrentCell(cell);
+    fillForCurrentCell(seqValue, dataRole, cell);
+    updateViewRules();
 
     const exec = async (): Promise<void> => {
       try {
@@ -415,9 +503,15 @@ async function getPolyToolEnumerateDialog(
             breadthPlaceholders: inputs.placeholdersBreadth.placeholdersBreadthValue,
             keepOriginal: inputs.keepOriginal.value,
           };
-          const toAtomicLevelV = inputs.toAtomicLevel.value && dataRole == PolyToolDataRole.macromolecule;
-          const enumeratorResDf = await polyToolEnumerateHelm(srcHelm, dataRole, srcId, params,
-            toAtomicLevelV, seqHelper, helmHelper);
+          const toAtomicLevelV: boolean = inputs.toAtomicLevel.value;
+          const enumeratorResDf = await polyToolEnumerateSeq(srcHelm, dataRole, srcId, params,
+            toAtomicLevelV ? {
+              generateHelm: inputs.generateHelm.value,
+              chiralityEngine: inputs.chiralityEngine.value,
+              highlightMonomers: inputs.highlightMonomers.value,
+              rules: await ruleInputs.getActive()
+            } : false,
+            helmHelper);
           grok.shell.addTableView(enumeratorResDf);
         }
       } catch (err: any) {
@@ -426,12 +520,27 @@ async function getPolyToolEnumerateDialog(
     };
 
     const dialog = ui.dialog({title: PT_UI_DIALOG_ENUMERATION, showFooter: true})
-      .add(inputs.macromolecule)
-      .add(inputs.placeholders)
-      .add(inputs.enumeratorType)
-      .add(inputs.placeholdersBreadth)
-      .add(inputs.trivialNameCol)
-      .add(ui.divH([inputs.keepOriginal.root, inputs.toAtomicLevel.root, inputs.toHarmonizedSequence.root],
+      .add(inputs.macromolecule.root)
+      .add(ui.divH([
+          ui.divV([
+              inputs.placeholders.root,
+              inputs.enumeratorType.root,],
+            {style: {width: '50%'}}
+          ),
+          ui.divV([
+              inputs.placeholdersBreadth.root],
+            {style: {width: '50%'}}),],
+        {style: {width: '100%'}}))
+      .add(ui.divH([
+          ui.divV([
+              inputs.trivialNameCol.root,
+              inputs.keepOriginal.root],
+            {style: {width: '50%'}}),
+          ui.divV([
+              ui.divH([inputs.toAtomicLevel.root, inputs.generateHelm.root]),
+              ui.divH([inputs.chiralityEngine.root, inputs.highlightMonomers.root]),
+              inputs.rules.header, inputs.rules.form],
+            {style: {width: '50%'}}),],
         {style: {width: '100%'}}))
       .add(warningsTextDiv)
       // .addButton('Enumerate', () => {
@@ -452,18 +561,24 @@ async function getPolyToolEnumerateDialog(
           trivialNameCol: inputs.trivialNameCol.stringValue,
           keepOriginal: inputs.keepOriginal.value,
           toAtomicLevel: inputs.toAtomicLevel.value,
-          toHarmonizedSequence: inputs.toHarmonizedSequence.value,
+          generateHelm: inputs.generateHelm.value,
+          chiralityEngine: inputs.chiralityEngine.value,
+          highlightMonomers: inputs.highlightMonomers.value,
+          rules: ruleFileList,
         };
       },
       /* applyInput */ (x: PolyToolEnumerateHelmSerialized): void => {
         inputs.macromolecule.stringValue = x.macromolecule;
         inputs.placeholders.stringValue = x.placeholders;
-        inputs.enumeratorType.value = x.enumeratorType;
+        inputs.enumeratorType.value = x.enumeratorType ?? PolyToolEnumeratorTypes.Single;
         inputs.placeholdersBreadth.stringValue = x.placeholdersBreadth;
         inputs.trivialNameCol.stringValue = x.trivialNameCol;
-        inputs.keepOriginal.value = x.keepOriginal;
-        inputs.toAtomicLevel.value = x.toAtomicLevel;
-        inputs.toHarmonizedSequence.value = x.toHarmonizedSequence;
+        inputs.keepOriginal.value = x.keepOriginal ?? false;
+        inputs.toAtomicLevel.value = x.toAtomicLevel ?? true;
+        inputs.generateHelm.value = x.generateHelm ?? true;
+        inputs.chiralityEngine.value = x.chiralityEngine ?? false;
+        inputs.highlightMonomers.value = x.highlightMonomers ?? false;
+        ruleInputs.setActive(x.rules);
       });
     return dialog;
   } catch (err: any) {
@@ -476,13 +591,17 @@ async function getPolyToolEnumerateDialog(
  * @param {DG.SemanticValue} srcValue Source value to enumerate, either of data role
  *                                    {@link PolyToolDataRole.template} or {@link PolyToolDataRole.macromolecule}
  * */
-async function polyToolEnumerateHelm(
+async function polyToolEnumerateSeq(
   srcHelm: string, dataRole: PolyToolDataRole, srcId: { value: string, colName: string } | null,
-  params: PolyToolEnumeratorParams, toAtomicLevel: boolean, seqHelper: ISeqHelper, helmHelper: IHelmHelper
+  params: PolyToolEnumeratorParams,
+  toAtomicLevel: { generateHelm: boolean, chiralityEngine: boolean, highlightMonomers: boolean, rules: string[] } | false,
+  helmHelper: IHelmHelper
 ): Promise<DG.DataFrame> {
   const pi = DG.TaskBarProgressIndicator.create('PolyTool enumerating...');
   try {
-    await getHelmHelper(); // initializes JSDraw and org
+    const libHelper = await getMonomerLibHelper();
+    const rdKitModule = await getRdKitModule();
+    const monomerLib = libHelper.getMonomerLib(); // TODO: Get monomer lib from src SeqValueBase
 
     const resList = doPolyToolEnumerateHelm(srcHelm, srcId?.value ?? '', params);
     let enumCol: DG.Column<string>;
@@ -500,9 +619,9 @@ async function polyToolEnumerateHelm(
         templateList[rowIdx] = chain.getNotation();
       }
       enumCol = DG.Column.fromList(DG.COLUMN_TYPE.STRING, 'Enumerated', templateList);
-      // enumCol.semType = DG.SEMTYPE.MACROMOLECULE;
-      // enumCol.setTag(PolyToolTags.dataRole, PolyToolDataRole.template);
-      // applyNotationProviderForCyclized(enumCol, '-');
+      enumCol.semType = DG.SEMTYPE.MACROMOLECULE;
+      enumCol.setTag(PolyToolTags.dataRole, PolyToolDataRole.template);
+      applyNotationProviderForCyclized(enumCol, '-');
       break;
     }
     }
@@ -512,10 +631,20 @@ async function polyToolEnumerateHelm(
       applyNotationProviderForCyclized(enumCol, '-');
     }
 
-    if (toAtomicLevel && dataRole != PolyToolDataRole.template) {
-      const seqHelper: ISeqHelper = await getSeqHelper();
-      const toAtomicLevelRes = await seqHelper.helmToAtomicLevel(enumCol, true, true);
-      enumeratorResDf.columns.add(toAtomicLevelRes.molCol!, false);
+    if (toAtomicLevel) {
+      let resHelmCol: DG.Column<string>;
+      if (dataRole === PolyToolDataRole.macromolecule) {
+        resHelmCol = enumCol;
+        const talRes = await helmHelper.seqHelper.helmToAtomicLevel(resHelmCol,
+          toAtomicLevel.chiralityEngine, toAtomicLevel.highlightMonomers);
+        enumeratorResDf.columns.add(talRes.molCol!, false);
+        const resMolCol = talRes.molCol!;
+        buildMonomerHoverLink(resHelmCol, resMolCol, monomerLib, helmHelper.seqHelper, rdKitModule);
+      } else if (dataRole === PolyToolDataRole.template) {
+        const talRes = await polyToolConvert(enumCol,
+          toAtomicLevel.generateHelm, toAtomicLevel.chiralityEngine, toAtomicLevel.rules);
+        resHelmCol = talRes[0];
+      }
     }
 
     if (srcId) {

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

@@ -9,7 +9,7 @@ import {
 } from '@datagrok-libraries/bio/src/helm/types';
 
 
-import {Chain} from './pt-conversion';
+import {Chain, PtBio} from './conversion/pt-chain';
 import {getAvailableMonomers} from './utils';
 import {PolyToolEnumeratorParams, PolyToolEnumeratorTypes, PolyToolPlaceholder, PolyToolBreadthPlaceholder} from './types';
 
@@ -76,7 +76,7 @@ function getPtEnumeratorBreadth(m: HelmMol, placeholdersBreadth: PolyToolBreadth
 export function doPolyToolEnumerateHelm(
   helm: string, id: string, params: PolyToolEnumeratorParams
 ): [ /* helm */ string, /* id */ string][] {
-  const molHandler = new JSDraw2.MolHandler<HelmType, IHelmEditorOptions>();
+  const molHandler = new JSDraw2.MolHandler<HelmType, PtBio, IHelmEditorOptions>();
   const plugin = new org.helm.webeditor.Plugin(molHandler);
   org.helm.webeditor.IO.parseHelm(plugin, helm, new JSDraw2.Point(0, 0), undefined);
   const m = molHandler.m;