@datagrok/sequence-translator 1.3.9 → 1.3.11

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@datagrok/sequence-translator",
   "friendlyName": "Sequence Translator",
-  "version": "1.3.9",
+  "version": "1.3.11",
   "author": {
     "name": "Alexey Choposky",
     "email": "achopovsky@datagrok.ai"

package/src/apps/pattern/model/const.ts

@@ -57,6 +57,12 @@ export namespace LEGEND_SETTINGS_KEYS {
 export namespace PATTERN_RECORD_KEYS {
   export const PATTERN_CONFIG = 'patternConfig';
   export const AUTHOR_ID = 'authorID';
+  export const DATE = 'date';
+}
+
+export namespace DATE_KEYS {
+  export const CREATE = 'create';
+  export const MODIFY = 'modify';
 }
 
 export const GRAPH_SETTINGS_KEY_LIST = [
@@ -72,11 +78,6 @@ export const LEGEND_SETTINGS_KEY_LIST = [
   LEGEND_SETTINGS_KEYS.NUCLEOTIDES_WITH_NUMERIC_LABELS
 ];
 
-export const PATTERN_RECORD_KEY_LIST = [
-  PATTERN_RECORD_KEYS.PATTERN_CONFIG,
-  PATTERN_RECORD_KEYS.AUTHOR_ID
-];
-
 export const EXAMPLE_PATTERN_CONFIG =
 {
   'patternConfig': {
@@ -119,3 +120,5 @@ export const EXAMPLE_PATTERN_CONFIG =
   },
   'authorID': ''
 };
+
+export const DEFAULT_DATE = '2024-01-01T18:00:00.000Z';

package/src/apps/pattern/model/data-manager.ts

@@ -3,7 +3,8 @@ import * as grok from 'datagrok-api/grok';
 
 import {
   EXAMPLE_PATTERN_CONFIG,
-  GRAPH_SETTINGS_KEY_LIST as GKL, LEGEND_SETTINGS_KEYS as L, OTHER_USERS, PATTERN_RECORD_KEYS as R, STORAGE_NAME
+  GRAPH_SETTINGS_KEY_LIST as GKL, LEGEND_SETTINGS_KEYS as L,
+  OTHER_USERS, PATTERN_RECORD_KEYS as R, STORAGE_NAME, DATE_KEYS as D
 } from './const';
 import {
   PatternConfigRecord, PatternConfiguration, PatternExistsError, PatternNameExistsError, RawPatternRecords
@@ -76,7 +77,7 @@ export class DataManager {
     return patternHash;
   }
 
-  async getPatternRecord(hash: string): Promise<PatternConfigRecord | null> {
+  async getPatternRecordByHash(hash: string): Promise<PatternConfigRecord | null> {
     if (hash === null || hash === '')
       return null;
     try {
@@ -91,7 +92,7 @@ export class DataManager {
   async getPatternConfig(hash: string | null): Promise<PatternConfiguration | null> {
     if (hash === '' || hash === null)
       return null;
-    const record = await this.getPatternRecord(hash);
+    const record = await this.getPatternRecordByHash(hash);
     const config = record === null ? null : record[R.PATTERN_CONFIG] as PatternConfiguration;
     return config;
   }
@@ -144,13 +145,13 @@ export class DataManager {
     return hash;
   }
 
-  private async getRecordFromPattern(patternConfig: PatternConfiguration): Promise<string> {
-    const record = {
+  private async getRecordFromPattern(
+    patternConfig: PatternConfiguration
+  ): Promise<PatternConfigRecord> {
+    return {
       [R.PATTERN_CONFIG]: patternConfig,
       [R.AUTHOR_ID]: await grok.dapi.users.current().then((u) => u.id),
     };
-    const stringifiedRecord = JSON.stringify(record);
-    return stringifiedRecord;
   }
 
   private getHash(patternConfig: PatternConfiguration): string {
@@ -173,13 +174,21 @@ export class DataManager {
       const patternName = patternConfig[L.PATTERN_NAME];
       this.validatePatternNameUniqueness(patternName);
 
-      const record = await this.getRecordFromPattern(patternConfig);
+      const recordObj = await this.getRecordFromPattern(patternConfig);
+      const timestamp = new Date().toISOString();
+      recordObj[R.DATE] = {
+        [D.CREATE]: timestamp,
+        [D.MODIFY]: timestamp,
+      };
+      const record = JSON.stringify(recordObj);
       await grok.dapi.userDataStorage.postValue(STORAGE_NAME, hash, record, false);
       this.currentUserPatternNameToHash.set(patternName, hash);
 
       eventBus.selectAuthor(this.getCurrentUserAuthorshipCategory());
 
       eventBus.updatePatternList();
+      eventBus.requestPatternLoad(hash);
+      eventBus.updateUrlState(hash);
     } catch (e) {
       if (e instanceof PatternNameExistsError || e instanceof PatternExistsError)
         throw e;
@@ -188,17 +197,33 @@ export class DataManager {
     }
   }
 
-  async overwritePatternInUserStorage(
+  async overwriteExistingPatternInUserStorage(
     eventBus: EventBus
   ): Promise<void> {
     const patternConfig = eventBus.getPatternConfig();
-    const hash = this.getHash(patternConfig);
     const patternName = patternConfig[L.PATTERN_NAME];
-    const record = await this.getRecordFromPattern(patternConfig);
-    await grok.dapi.userDataStorage.postValue(STORAGE_NAME, hash, record, false);
-    this.currentUserPatternNameToHash.set(patternName, hash);
-    // eventBus.selectUser(this.getCurrentUserAuthorshipCategory());
-    eventBus.updatePatternList();
+    const oldHash = this.currentUserPatternNameToHash.get(patternName);
+
+    if (oldHash === undefined)
+      throw new Error(`Old hash is undefined`);
+    const newHash = this.getHash(patternConfig);
+    const newRecordObj = await this.getRecordFromPattern(patternConfig);
+    const timestamp = new Date().toISOString();
+    newRecordObj[R.DATE] = {
+      [D.MODIFY]: timestamp,
+    };
+    const oldPattern = await grok.dapi.userDataStorage.getValue(STORAGE_NAME, oldHash, false);
+    const oldPatternsRecord = JSON.parse(oldPattern) as PatternConfigRecord;
+    if (oldPatternsRecord[R.DATE] !== undefined && oldPatternsRecord[R.DATE][D.CREATE] != undefined)
+      newRecordObj[R.DATE][D.CREATE] = oldPatternsRecord[R.DATE][D.CREATE];
+
+    const newRecord = JSON.stringify(newRecordObj);
+    await grok.dapi.userDataStorage.postValue(STORAGE_NAME, newHash, newRecord, false);
+    await grok.dapi.userDataStorage.remove(STORAGE_NAME, oldHash, false);
+
+    this.currentUserPatternNameToHash.set(patternName, newHash);
+    eventBus.requestPatternLoad(newHash);
+    eventBus.updateUrlState(newHash);
   }
 
   async deletePattern(

package/src/apps/pattern/model/event-bus.ts

@@ -434,6 +434,8 @@ export class EventBus {
   }
 
   selectAuthor(username: string) {
+    if (typeof username !== 'string')
+      throw new Error('Selected user must be defined');
     this._patternAuthorSelection$.next(username);
   }
 

package/src/apps/pattern/model/types.ts

@@ -1,11 +1,7 @@
-/* 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 {
   TERMINI, STRANDS,
-  GRAPH_SETTINGS_KEYS as G, LEGEND_SETTINGS_KEYS as L, PATTERN_RECORD_KEYS as R
+  GRAPH_SETTINGS_KEYS as G, LEGEND_SETTINGS_KEYS as L, PATTERN_RECORD_KEYS as R,
+  DATE_KEYS as D
 } from './const';
 
 export type StrandType = typeof STRANDS[number];
@@ -30,9 +26,15 @@ export type PatternLegendSettings = {
 
 export type PatternConfiguration = PatternGraphSettings & PatternLegendSettings;
 
+type DateRecord = {
+  [D.CREATE]?: string,
+  [D.MODIFY]: string;
+}
+
 export type PatternConfigRecord = {
   [R.PATTERN_CONFIG]: PatternConfiguration,
   [R.AUTHOR_ID]: string,
+  [R.DATE]?: DateRecord
 }
 
 export class PatternNameExistsError extends Error {

package/src/apps/pattern/view/components/load-block-controls.ts

@@ -94,12 +94,15 @@ export class PatternLoadControlsManager {
       possibleValues.push(this.dataManager.getOtherUsersAuthorshipCategory());
 
     const authorChoiceInput = ui.input.choice(
-      'Author', {value: this.eventBus.getSelectedAuthor(), items: possibleValues,
-        onValueChanged: (input) => {
-          this.authorSelectedByUser = true;
-          this.eventBus.selectAuthor(input.value);
-        }}
-    );
+      'Author', {value: this.eventBus.getSelectedAuthor(), items: possibleValues});
+
+    authorChoiceInput.onInput(() => {
+      this.authorSelectedByUser = true;
+      if (authorChoiceInput.value === null)
+        throw new Error('author choice must be non-null');
+      this.eventBus.selectAuthor(authorChoiceInput.value);
+    });
+
     this.setAuthorChoiceInputStyle(authorChoiceInput);
     authorChoiceInput.setTooltip('Select pattern author');
 

package/src/apps/pattern/view/components/right-section.ts

@@ -7,6 +7,7 @@ import {PatternExistsError, PatternNameExistsError} from '../../model/types';
 import {SvgDisplayManager} from '../svg-utils/svg-display-manager';
 import {NumericLabelVisibilityControls} from './numeric-label-visibility-controls';
 import {TranslationExamplesBlock} from './translation-examples-block';
+import {DEFAULT_DATE, PATTERN_RECORD_KEYS as P, DATE_KEYS as D, LEGEND_SETTINGS_KEYS as L} from '../../model/const';
 
 export class PatternAppRightSection {
   private svgDisplay: HTMLDivElement;
@@ -44,6 +45,7 @@ export class PatternAppRightSection {
       this.createSavePatternButton(),
       this.createDownloadPngButton(),
       this.createShareLinkButton(),
+      this.createInfoButton(),
     ], {style: {gap: '12px', marginTop: '12px'}});
   }
 
@@ -55,6 +57,53 @@ export class PatternAppRightSection {
     return svgDownloadButton;
   }
 
+  private createInfoButton(): HTMLButtonElement {
+    const shareLinkButton = ui.button(
+      ui.iconFA('info-circle'),
+      () => this.openInfoDialog()
+    );
+
+    this.eventBus.patternHasUnsavedChanges$.subscribe((hasUnsavedChanges: boolean) => {
+      shareLinkButton.disabled = hasUnsavedChanges;
+    });
+
+    ui.tooltip.bind(shareLinkButton, 'View pattern metadata');
+    return shareLinkButton;
+  }
+
+  private async openInfoDialog() {
+    let author = this.dataManager.getCurrentUserName();
+    let patternName = this.dataManager.getDefaultPatternName();
+    let createDate = DEFAULT_DATE;
+    let modifyDate = DEFAULT_DATE;
+    const hash = new URLSearchParams(window.location.search).get('pattern');
+    if (hash !== null) {
+      const record = await this.dataManager.getPatternRecordByHash(hash);
+      if (record !== null) {
+        const authorID = record[P.AUTHOR_ID];
+        const userFriendlyName = (await grok.dapi.users.find(authorID)).friendlyName;
+        author = userFriendlyName;
+        patternName = record[P.PATTERN_CONFIG][L.PATTERN_NAME];
+        if (record[P.DATE] !== undefined) {
+          const create = record[P.DATE][D.CREATE];
+          if (create !== undefined)
+            createDate = create;
+          const modify = record[P.DATE][D.MODIFY];
+          if (modify !== undefined)
+            modifyDate = modify;
+        }
+      }
+    }
+
+    const message = ui.divV([
+      ui.divText(`Author: ${author}`),
+      ui.divText(`Pattern Name: ${patternName}`),
+      ui.divText(`Created: ${new Date(createDate).toLocaleString()}`),
+      ui.divText(`Modified: ${new Date(modifyDate).toLocaleString()}`),
+    ]);
+    grok.shell.info(message);
+  }
+
   private createShareLinkButton(): HTMLButtonElement {
     const shareLinkButton = ui.button(
       ui.iconFA('link'),
@@ -135,7 +184,7 @@ class OverwritePatternDialog {
 
   private processOverwriteNamesakePattern(): void {
     const patternName = this.eventBus.getPatternName();
-    this.dataManager.overwritePatternInUserStorage(this.eventBus)
+    this.dataManager.overwriteExistingPatternInUserStorage(this.eventBus)
       .then(() => {
         grok.shell.info(`Pattern ${patternName} overwritten`);
       })

package/src/apps/pattern/view/ui.ts

@@ -55,7 +55,7 @@ async function getInitialPatternRecord(
     return dataManager.getDefaultPatternRecord();
   }
 
-  let initialPatternRecord = await dataManager.getPatternRecord(patternHash);
+  let initialPatternRecord = await dataManager.getPatternRecordByHash(patternHash);
   if (!initialPatternRecord) {
     urlRouter.clearPatternURL();
     initialPatternRecord = dataManager.getDefaultPatternRecord();

package/src/package.ts

@@ -16,12 +16,12 @@ import {demoOligoPatternUI, demoOligoStructureUI, demoOligoTranslatorUI} from '.
 import {getExternalAppViewFactories} from './plugins/mermade';
 
 //polytool specific
-import {getPolyToolConversionDialog} from './polytool/pt-dialog';
+import {getPolyToolConversionDialog, polyToolEnumerateHelmUI, polyToolEnumerateChemUI} from './polytool/pt-dialog';
 import {_setPeptideColumn} from './polytool/utils';
 import {PolyToolCsvLibHandler} from './polytool/csv-to-json-monomer-lib-converter';
 import {ITranslationHelper} from './types';
-import {polyToolEnumerateHelmUI, polyToolEnumerateChemUI} from './polytool/pt-ui';
 import {addContextMenuUI} from './utils/context-menu';
+import { NOTATION } from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
 
 export const _package: OligoToolkitPackage = new OligoToolkitPackage();
 
@@ -172,12 +172,12 @@ export async function polyToolEnumerateHelm(): Promise<void> {
   polyToolEnumerateHelmUI();
 }
 
-// //top-menu: Bio | Convert | PolyTool-Enumerate Chem
-// //name: polyToolEnumerateChem
-// //description: Perform cyclization of polymers
-// export async function polyToolEnumerateChem(): Promise<void> {
-//   polyToolEnumerateChemUI();
-// }
+//top-menu: Bio | Convert | PolyTool-Enumerate Chem
+//name: polyToolEnumerateChem
+//description: Perform cyclization of polymers
+export async function polyToolEnumerateChem(): Promise<void> {
+  polyToolEnumerateChemUI();
+}
 
 //name: polyToolColumnChoice
 //input: dataframe df [Input data table]
@@ -210,28 +210,40 @@ export function addContextMenu(event: DG.EventData): void {
 // //meta.icon: img/icons/structure.png
 // //meta.browsePath: PolyTool
 // //tags: app
-// //output: view v
-// export async function ptConverterApp(): Promise<DG.ViewBase> {
-//   const view = await getSpecifiedAppView(APP_NAME.STRUCTURE);
-//   return view;
+// export async function ptConverterApp(): Promise<void> {
+//   const view = grok.shell.v as DG.TableView;
+//   const table = view.dataFrame;
+//   const colNames = table.columns.names(); 
+//   let covertableName = '';
+
+//   for (let i = 0; i < colNames.length; i++) {
+//     const col = table.columns.byName(colNames[i]);
+//     if (col.semType === DG.SEMTYPE.MACROMOLECULE && col.meta.units === NOTATION.SEPARATOR) {
+//       covertableName = colNames[i];
+//       break;
+//     }
+//   }
+
+//   if (covertableName === '')
+//     grok.shell.error('To run the app open a view with convertable separator notation for macromolecules');
+//   else {
+//     const dialog = await getPolyToolConversionDialog();
+//     dialog.show();
+//   }  
 // }
 
-// //name: PolyTool Enumerator Helm
-// //meta.icon: img/icons/structure.png
-// //meta.browsePath: PolyTool
-// //tags: app
-// //output: view v
-// export async function ptEnumeratorHelmApp(): Promise<DG.ViewBase> {
-//   const view = await getSpecifiedAppView(APP_NAME.STRUCTURE);
-//   return view;
-// }
+//name: PolyTool Enumerator Helm
+//meta.icon: img/icons/structure.png
+//meta.browsePath: PolyTool
+//tags: app
+export async function ptEnumeratorHelmApp(): Promise<void> {
+  polyToolEnumerateHelmUI();
+}
 
-// //name: PolyTool Enumerator Chem
-// //meta.icon: img/icons/structure.png
-// //meta.browsePath: PolyTool
-// //tags: app
-// //output: view v
-// export async function ptEnumeratorChemApp(): Promise<DG.ViewBase> {
-//   const view = await getSpecifiedAppView(APP_NAME.STRUCTURE);
-//   return view;
-// }
+//name: PolyTool Enumerator Chem
+//meta.icon: img/icons/structure.png
+//meta.browsePath: PolyTool
+//tags: app
+export async function ptEnumeratorChemApp(): Promise<void> {
+  polyToolEnumerateChemUI();
+}

package/src/polytool/pt-dialog.ts

@@ -28,7 +28,27 @@ const PT_UI_DIALOG_CONVERSION = 'Poly Tool Conversion';
 const PT_UI_DIALOG_ENUMERATION = 'Poly Tool Enumeration';
 const PT_UI_RULES_USED = 'Rules used';
 
-export async function getPolyToolConversionDialog(): Promise<DG.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');
+    });
+}
+
+export async function getPolyToolConversionDialog(targetCol?: DG.Column): Promise<DG.Dialog> {
   const targetColumns = grok.shell.t.columns.bySemTypeAll(DG.SEMTYPE.MACROMOLECULE);
   if (!targetColumns)
     throw new Error(PT_ERROR_DATAFRAME);
@@ -38,6 +58,8 @@ export async function getPolyToolConversionDialog(): Promise<DG.Dialog> {
     filter: (col: DG.Column) => col.semType === DG.SEMTYPE.MACROMOLECULE
   });
 
+  targetColumnInput.value = targetCol ? targetCol : targetColumnInput.value;
+
   const generateHelmChoiceInput = ui.input.bool(PT_UI_GET_HELM, {value: true});
   ui.tooltip.bind(generateHelmChoiceInput.root, PT_UI_ADD_HELM);
 
@@ -82,7 +104,7 @@ export async function getPolyToolConversionDialog(): Promise<DG.Dialog> {
   return dialog;
 }
 
-export async function getPolyToolEnumerationHelmDialog(cell?: DG.Cell): Promise<DG.Dialog> {
+async function getPolyToolEnumerationHelmDialog(cell?: DG.Cell): Promise<DG.Dialog> {
   const [libList, helmHelper] = await Promise.all([
     getLibrariesList(), getHelmHelper()]);
 
@@ -137,7 +159,7 @@ export async function getPolyToolEnumerationHelmDialog(cell?: DG.Cell): Promise<
   return dialog;
 }
 
-export async function getPolyToolEnumerationChemDialog(cell?: DG.Cell): Promise<DG.Dialog> {
+async function getPolyToolEnumerationChemDialog(cell?: DG.Cell): Promise<DG.Dialog> {
   const [libList, helmHelper] = await Promise.all([
     getLibrariesList(), getHelmHelper()]);
 
@@ -147,9 +169,6 @@ export async function getPolyToolEnumerationChemDialog(cell?: DG.Cell): Promise<
   // 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';

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

@@ -29,7 +29,7 @@ export const PT_CHEM_EXAMPLE = `
     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
+    3.1670    1.7285    0.0000 O   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
@@ -55,18 +55,15 @@ export const PT_CHEM_EXAMPLE = `
  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  RGP  1  22   1
 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 enumerations = new Array<string>(variableMonomers.length);
 
 	const rdkitModule: RDModule = await grok.functions.call('Chem:getRdKitModule');
   const molScaffold: RDMol = rdkitModule.get_mol(molString);
@@ -84,22 +81,39 @@ export async function getEnumerationChem(molString: string, screenLibrary: strin
     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] = '';
+  for (let i = 0; i < variableMonomers.length; i++) {
+    let molRes: RDMol | null = null;
+    try {
+      //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);
+      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) {
+      enumerations[i] = '';
+    }
+    finally {
+      molRes?.delete();
+    }
   }
+  
 
   return enumerations;
 }

package/src/utils/context-menu.ts

@@ -6,7 +6,7 @@ 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';
+import {polyToolEnumerateHelmUI} from '../polytool/pt-dialog';
 
 export type SequenceTranslatorWindowType = Window & {
   $sequenceTranslator?: {

package/src/polytool/pt-ui.ts

@@ -1,25 +0,0 @@
-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');
-    });
-}