@datagrok/sequence-translator 1.3.10 → 1.3.12

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);
+  }
 }

package/src/polytool/pt-placeholders-input.ts

@@ -0,0 +1,127 @@
+import * as ui from 'datagrok-api/ui';
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+
+import {PolyToolPlaceholders} from './types';
+
+export class PolyToolPlaceholdersInput extends DG.JsInputBase<DG.DataFrame> {
+  get inputType(): string { return 'Positions'; }
+
+  get dataType(): string { return DG.TYPE.DATA_FRAME; }
+
+  getInput(): HTMLElement { return this.gridHost; }
+
+  getValue(): DG.DataFrame {
+    return this.grid.dataFrame;
+  }
+
+  setValue(value: DG.DataFrame): void {
+    this.grid.dataFrame = value;
+  }
+
+  getStringValue(): string {
+    return this.grid.dataFrame.toCsv();
+  }
+
+  setStringValue(str: string): void {
+    this.grid.dataFrame = DG.DataFrame.fromCsv(str);
+  }
+
+  get placeholdersValue() {
+    return dfToPlaceholders(this.grid.dataFrame);
+  }
+
+  private readonly gridHost: HTMLDivElement;
+  public readonly grid: DG.Grid;
+
+  protected constructor(name: string | undefined, grid: DG.Grid, heightRowCount?: number) {
+    super();
+
+    if (name) this.captionLabel.innerText = name;
+
+    this.gridHost = ui.div([], {
+      classes: 'ui-input-editor',
+      style: {width: '100%', height: '100%', marginTop: '-8px'},
+    });
+
+    this.grid = grid;
+    this.gridHost.append(this.grid.root);
+
+    if (heightRowCount != null) {
+      this.updateGridHeight(heightRowCount + 0.7);
+    } else {
+      this.updateGridHeight(this.grid.dataFrame.rowCount + 0.6);
+      this.grid.dataFrame.onRowsAdded
+        .subscribe(() => { this.updateGridHeight(this.grid.dataFrame.rowCount + 0.6); });
+    }
+    this.grid.root.style.width = `100%`;
+
+    ui.onSizeChanged(this.grid.root).subscribe(() => {
+      this.grid.columns.byIndex(2)!.width = this.grid.root.clientWidth - this.grid.horzScroll.root.offsetWidth -
+        this.grid.columns.byIndex(0)!.width - this.grid.columns.byIndex(1)!.width - 10;
+    });
+
+    this.root.classList.add('ui-input-polytool-pos-grid');
+    this.root.append(this.gridHost);
+  }
+
+  public static async create(
+    name?: string, value?: DG.DataFrame, options?: {}, heightRowCount?: number
+  ): Promise<PolyToolPlaceholdersInput> {
+    const df: DG.DataFrame = value ?? DG.DataFrame.create(0);
+    const grid = (await df.plot.fromType(DG.VIEWER.GRID, options)) as DG.Grid;
+    return new PolyToolPlaceholdersInput(name, grid, heightRowCount);
+  }
+
+  // -- Update view --
+
+  private updateGridHeight(visibleRowCount: number): void {
+    const gridHeight = this.grid.colHeaderHeight + visibleRowCount * this.grid.props.rowHeight + 6 + 2;
+    this.grid.root.style.height = `${gridHeight}px`;
+  }
+
+  // -- Handle events --
+
+  private rootOnSizeChanged(): void {
+
+  }
+}
+
+export function getPlaceholdersFromText(src: string): PolyToolPlaceholders {
+  const res: PolyToolPlaceholders = {};
+  for (const line of src.split('\n')) {
+    const lineM = /^\s*(?<pos>\d+)\s*:\s*(?<monomers>.+)$/.exec(line);
+    if (lineM) {
+      const pos: number = parseInt(lineM.groups!['pos']) - 1;
+      const monomerList: string[] = lineM.groups!['monomers'].split(',').map(m => m.trim());
+      if (!(pos in res)) res[pos] = [];
+      res[pos].push(...monomerList);
+    }
+  }
+  return res;
+}
+
+export function dfToPlaceholders(df: DG.DataFrame): PolyToolPlaceholders {
+  const res: PolyToolPlaceholders = {};
+  for (let rowI = 0; rowI < df.rowCount; rowI++) {
+    const pos = parseInt(df.get('Position', rowI));
+    if (!isNaN(pos)) {
+      const monomerSymbolList = parseMonomerSymbolList(df.get('Monomers', rowI));
+      if (monomerSymbolList.length > 0)
+        res[pos - 1] = monomerSymbolList;
+    }
+  }
+  return res;
+}
+
+export function parseMonomerSymbolList(src: string): string[] {
+  // L, L-hArg(Et,Et), "hArg(Et,Et)"
+  return src.split(/,(?![^(]*\))/)
+    .map((s) => {
+      s = s.trim();
+      if (s.slice(0, 1) === `"` && s.slice(-1) === `"`) s = s.slice(1, -1);
+      if (s.slice(0, 1) === `'` && s.slice(-1) === `'`) s = s.slice(1, -1);
+      return s.trim();
+    })
+    .filter((s) => !!s);
+}

package/src/polytool/types.ts

@@ -0,0 +1,18 @@
+import * as ui from 'datagrok-api/ui';
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+
+export enum PolyToolEnumeratorTypes {
+  Single = 'single',
+  Matrix = 'matrix',
+}
+
+export type PolyToolEnumeratorType = typeof PolyToolEnumeratorTypes[keyof typeof PolyToolEnumeratorTypes];
+
+export type PolyToolPlaceholders = { [position: number]: string[] };
+
+export type PolyToolEnumeratorParams = {
+  type: PolyToolEnumeratorType;
+  /** position key is zero-based */
+  placeholders: PolyToolPlaceholders;
+}

package/src/tests/polytool-enumerate-tests.ts

@@ -0,0 +1,78 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {before, after, category, expect, test, expectArray} from '@datagrok-libraries/utils/src/test';
+import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
+
+import {PolyToolEnumeratorParams, PolyToolEnumeratorTypes} from '../polytool/types';
+import {polyToolEnumerateHelm} from '../package';
+import {getPtEnumeratorHelm} from '../polytool/pt-enumeration-helm';
+import {HelmMol} from '@datagrok-libraries/bio/src/helm/types';
+
+category('PolyTool', () => {
+  let helmHelper: IHelmHelper;
+
+  before(async () => {
+    helmHelper = await getHelmHelper(); // initialize JSDraw2 and org
+  });
+
+  after(async () => {
+
+  });
+
+  const tests: {
+    [testName: string]: { src: string, params: PolyToolEnumeratorParams, tgt: string[] }
+  } = {
+    'single1': {
+      src: 'PEPTIDE1{[Ac(1)].F.W.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$',
+      params: {
+        type: PolyToolEnumeratorTypes.Single,
+        placeholders: {
+          [4]: ['K', 'P', 'F4COO'],
+          [6]: ['Y', 'T'],
+        }
+      },
+      tgt: [
+        'PEPTIDE1{[Ac(1)].F.W.G.K.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0',
+        'PEPTIDE1{[Ac(1)].F.W.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0',
+        'PEPTIDE1{[Ac(1)].F.W.G.[F4COO].L.[Tic].[C(1)].G.[NH2]}$$$$V2.0',
+        'PEPTIDE1{[Ac(1)].F.W.G.P.L.Y.[C(1)].G.[NH2]}$$$$V2.0',
+        'PEPTIDE1{[Ac(1)].F.W.G.P.L.T.[C(1)].G.[NH2]}$$$$V2.0',
+      ]
+    },
+    'matrix1': {
+      src: 'PEPTIDE1{[Ac(1)].F.W.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$',
+      params:
+        {
+          type: PolyToolEnumeratorTypes.Matrix,
+          placeholders: {
+            [1]: ['D', 'L'],
+            [4]: ['K', 'P', 'F4COO'],
+            [6]: ['Y', 'T'],
+          }
+        },
+      tgt: [
+        'PEPTIDE1{[Ac(1)].D.W.G.K.L.Y.[C(1)].G.[NH2]}$$$$V2.0',
+        'PEPTIDE1{[Ac(1)].D.W.G.K.L.T.[C(1)].G.[NH2]}$$$$V2.0',
+        'PEPTIDE1{[Ac(1)].D.W.G.P.L.Y.[C(1)].G.[NH2]}$$$$V2.0',
+        'PEPTIDE1{[Ac(1)].D.W.G.P.L.T.[C(1)].G.[NH2]}$$$$V2.0',
+        'PEPTIDE1{[Ac(1)].D.W.G.[F4COO].L.Y.[C(1)].G.[NH2]}$$$$V2.0',
+        'PEPTIDE1{[Ac(1)].D.W.G.[F4COO].L.T.[C(1)].G.[NH2]}$$$$V2.0',
+        'PEPTIDE1{[Ac(1)].L.W.G.K.L.Y.[C(1)].G.[NH2]}$$$$V2.0',
+        'PEPTIDE1{[Ac(1)].L.W.G.K.L.T.[C(1)].G.[NH2]}$$$$V2.0',
+        'PEPTIDE1{[Ac(1)].L.W.G.P.L.Y.[C(1)].G.[NH2]}$$$$V2.0',
+        'PEPTIDE1{[Ac(1)].L.W.G.P.L.T.[C(1)].G.[NH2]}$$$$V2.0',
+        'PEPTIDE1{[Ac(1)].L.W.G.[F4COO].L.Y.[C(1)].G.[NH2]}$$$$V2.0',
+        'PEPTIDE1{[Ac(1)].L.W.G.[F4COO].L.T.[C(1)].G.[NH2]}$$$$V2.0',
+      ],
+    }
+  };
+
+  for (const [testName, testData] of Object.entries(tests)) {
+    test(`enumerator-${testName}`, async () => {
+      const res = getPtEnumeratorHelm(testData.src, testData.params);
+      expectArray(res, testData.tgt);
+    });
+  }
+});

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/utils/err-info.ts

@@ -6,8 +6,8 @@ import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
 
 import {_package} from '../package';
 
-export function defaultErrorHandler(err: any): void {
+export function defaultErrorHandler(err: any, shell: boolean = true): void {
   const [errMsg, errStack] = errInfo(err);
   _package.logger.error(errMsg, undefined, errStack);
-  grok.shell.error(errMsg);
+  if (shell) grok.shell.error(errMsg);
 }

package/webpack.config.js

@@ -17,16 +17,9 @@ module.exports = {
   },
   module: {
     rules: [
-      {
-        test: /\.ts(x?)$/,
-        use: 'ts-loader',
-        exclude: /node_modules/,
-      },
-      {
-        test: /\.css$/,
-        use: ['style-loader', 'css-loader'],
-        exclude: /node_modules/,
-      },
+      {test: /\.js$/, enforce: 'pre', use: ['source-map-loader'], exclude: [/node_modules/]},
+      {test: /\.ts(x?)$/, use: 'ts-loader', exclude: [/node_modules/]},
+      {test: /\.css$/, use: ['style-loader', 'css-loader'], exclude: [/node_modules/]},
     ],
   },
   devtool: 'source-map',

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');
-    });
-}