@datagrok/sequence-translator 1.4.8 → 1.5.0

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

@@ -2,9 +2,10 @@ import * as ui from 'datagrok-api/ui';
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 
-import {Unsubscribable} from 'rxjs';
+import {fromEvent, Unsubscribable} from 'rxjs';
 import {PolyToolBreadthPlaceholder} from './types';
 import {parseMonomerSymbolList} from './pt-placeholders-input';
+import {GridCellRenderArgs} from 'datagrok-api/dg';
 
 export class PolyToolPlaceholdersBreadthInput extends DG.JsInputBase<DG.DataFrame> {
   get inputType(): string { return 'Breadth'; }
@@ -15,71 +16,110 @@ export class PolyToolPlaceholdersBreadthInput extends DG.JsInputBase<DG.DataFram
 
   getValue(): DG.DataFrame { return this.grid.dataFrame; }
 
-  setValue(value: DG.DataFrame): void { this.grid.dataFrame = value; }
+  setValue(value: DG.DataFrame): void {
+    this.setDataFrame(value);
+  }
 
   getStringValue(): string { return this.grid.dataFrame.toCsv(); }
 
-  setStringValue(str: string): void { this.grid.dataFrame = DG.DataFrame.fromCsv(str); }
+  setStringValue(str: string): void {
+    this.setDataFrame(DG.DataFrame.fromCsv(str));
+  }
 
   get placeholdersBreadthValue(): PolyToolBreadthPlaceholder[] {
     return dfToPlaceholdersBreadth(this.grid.dataFrame);
   }
 
   private readonly gridHost: HTMLDivElement;
-  public readonly grid: DG.Grid;
+  public grid: DG.Grid;
 
   private subs: Unsubscribable[] = [];
 
-  protected constructor(name: string | undefined, grid: DG.Grid, heightRowCount?: number) {
+  protected constructor(
+    private readonly name: string | undefined,
+    heightRowCount?: number, options?: {}
+  ) {
     super();
 
-    if (name) this.captionLabel.innerText = name;
-
-    this.gridHost = ui.div([], {
+    this.caption = name ?? '';
+    this.root.classList.add('ui-input-polytool-pos-grid');
+    this.root.append(this.gridHost = ui.div([], {
       classes: 'ui-input-editor',
       style: {width: '100%', height: '100%', marginTop: '-8px', marginBottom: '8px', paddingBottom: '4px'},
+    }));
+    this.render(heightRowCount, options).then(() => {});
+  }
+
+  detach(): void {
+    for (const sub of this.subs) sub.unsubscribe();
+    for (const sub of this.dataFrameSubs) sub.unsubscribe();
+  }
+
+  async render(heightRowCount?: number, options?: {}): Promise<void> {
+    let removeCol: DG.Column<boolean>;
+    const df: DG.DataFrame = DG.DataFrame.fromColumns([
+      removeCol = DG.Column.fromType(DG.COLUMN_TYPE.STRING, 'Remove', 0),
+      DG.Column.fromType(DG.COLUMN_TYPE.INT, 'Start', 0),
+      DG.Column.fromType(DG.COLUMN_TYPE.INT, 'End', 0),
+      DG.Column.fromType(DG.COLUMN_TYPE.STRING, 'Monomers', 0),
+    ])!;
+    removeCol.setTag(DG.TAGS.FRIENDLY_NAME, '');
+    this.grid = (await df.plot.fromType(DG.VIEWER.GRID, options)) as DG.Grid;
+    this.grid.sort(['Start', 'End']);
+    this.grid.columns.byIndex(1)!.width = this.grid.props.rowHeight + 2;
+
+    this.grid.onCellRender.subscribe((eventArgs: GridCellRenderArgs) => {
+      const gridCell = eventArgs.cell;
+      if (gridCell.tableColumn?.name == removeCol.name && (gridCell?.tableRowIndex ?? -1) >= 0) {
+        gridCell.element = ui.div(ui.icons.delete(() => {
+          this.grid.dataFrame.rows.removeAt(gridCell.tableRowIndex!);
+        }, 'Delete'), {
+          style: {
+            height: `${gridCell.grid.props.rowHeight}px`, color: 'var(--grey-6)',
+            display: 'flex', flexDirection: 'row', justifyContent: 'center'
+          }
+        });
+      }
     });
 
-    this.grid = grid;
-    this.gridHost.append(this.grid.root);
+    this.updateGridHeight(heightRowCount ?? this.grid.dataFrame.rowCount + 0.7);
+    this.subs.push(ui.onSizeChanged(this.grid.root)
+      .subscribe(this.gridRootOnSizeChanged.bind(this)));
+    this.subs.push(fromEvent<KeyboardEvent>(this.grid.root, 'keydown')
+      .subscribe((e: KeyboardEvent) => {
+        if (e.key === 'Enter') e.stopPropagation();
+      }));
+    this.setDataFrame(df);
 
-    if (heightRowCount != null) {
-      this.updateGridHeight(heightRowCount + 0.7);
-    } else {
-      this.updateGridHeight(this.grid.dataFrame.rowCount + 0.6);
-      this.subs.push(this.grid.dataFrame.onRowsAdded
-        .subscribe(() => { this.updateGridHeight(this.grid.dataFrame.rowCount + 0.6); }));
-    }
     this.grid.root.style.width = `100%`;
+    this.gridHost.append(this.grid.root);
+  }
 
-    this.subs.push(this.grid.dataFrame.onDataChanged.subscribe(() => {
-      this.fireChanged();
-    }));
+  private dataFrameSubs: Unsubscribable[] = [];
 
-    this.subs.push(ui.onSizeChanged(this.grid.root).subscribe(() => {
-      this.grid.columns.byIndex(3)!.width = this.grid.root.clientWidth - this.grid.horzScroll.root.offsetWidth -
-        this.grid.columns.byIndex(0)!.width - this.grid.columns.byIndex(1)!.width - this.grid.columns.byIndex(2)!.width - 10;
-    }));
+  private setDataFrame(dataFrame: DG.DataFrame): void {
+    for (const sub of this.dataFrameSubs) sub.unsubscribe();
+    this.grid.dataFrame = dataFrame;
 
-    this.root.classList.add('ui-input-polytool-pos-grid');
-    this.root.append(this.gridHost);
-  }
+    this.dataFrameSubs.push(this.grid.dataFrame.onRowsRemoved
+      .subscribe(() => {
+        this.updateGridHeight(this.grid.dataFrame.rowCount + 0.7);
+        this.fireChanged();
+      }));
+    this.dataFrameSubs.push(this.grid.dataFrame.onRowsAdded
+      .subscribe(() => { this.updateGridHeight(this.grid.dataFrame.rowCount + 0.7); }));
+    this.dataFrameSubs.push(this.grid.dataFrame.onDataChanged.subscribe(() => {
+      this.fireChanged();
+    }));
 
-  detach(): void {
-    for (const sub of this.subs) sub.unsubscribe();
+    this.updateGridHeight(this.grid.dataFrame.rowCount + 0.7);
+    this.fireChanged();
   }
 
   public static async create(
     name?: string, options?: {}, heightRowCount?: number
   ): Promise<PolyToolPlaceholdersBreadthInput> {
-    const df: DG.DataFrame = DG.DataFrame.fromColumns([
-      DG.Column.fromType(DG.COLUMN_TYPE.INT, 'Start', 0),
-      DG.Column.fromType(DG.COLUMN_TYPE.INT, 'End', 0),
-      DG.Column.fromType(DG.COLUMN_TYPE.STRING, 'Monomers', 0),
-    ])!;
-    const grid = (await df.plot.fromType(DG.VIEWER.GRID, options)) as DG.Grid;
-    grid.sort(['Start', 'End']);
-    return new PolyToolPlaceholdersBreadthInput(name, grid, heightRowCount);
+    return new PolyToolPlaceholdersBreadthInput(name, heightRowCount, options);
   }
 
   // -- Update view --
@@ -92,8 +132,9 @@ export class PolyToolPlaceholdersBreadthInput extends DG.JsInputBase<DG.DataFram
   // -- Handle events --
 
   private gridRootOnSizeChanged(): void {
-    this.grid.columns.byIndex(3)!.width = this.grid.root.clientWidth - this.grid.horzScroll.root.offsetWidth -
-      this.grid.columns.byIndex(0)!.width - this.grid.columns.byIndex(1)!.width - this.grid.columns.byIndex(2)!.width - 10;
+    this.grid.columns.byIndex(4)!.width = this.grid.root.clientWidth - this.grid.horzScroll.root.offsetWidth -
+      this.grid.columns.byIndex(0)!.width - this.grid.columns.byIndex(1)!.width -
+      this.grid.columns.byIndex(2)!.width - this.grid.columns.byIndex(3)!.width - 10;
   }
 }
 

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

@@ -2,9 +2,10 @@ import * as ui from 'datagrok-api/ui';
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 
-import {Unsubscribable} from 'rxjs';
+import {fromEvent, Unsubscribable} from 'rxjs';
 
 import {PolyToolPlaceholder} from './types';
+import {GridCellRenderArgs} from 'datagrok-api/dg';
 
 export class PolyToolPlaceholdersInput extends DG.JsInputBase<DG.DataFrame> {
   get inputType(): string { return 'Positions'; }
@@ -15,69 +16,126 @@ export class PolyToolPlaceholdersInput extends DG.JsInputBase<DG.DataFrame> {
 
   getValue(): DG.DataFrame { return this.grid.dataFrame; }
 
-  setValue(value: DG.DataFrame): void { this.grid.dataFrame = value; }
+  setValue(value: DG.DataFrame): void {
+    this.setDataFrame(value);
+  }
 
   getStringValue(): string { return this.grid.dataFrame.toCsv(); }
 
-  setStringValue(str: string): void { this.grid.dataFrame = DG.DataFrame.fromCsv(str); }
+  setStringValue(str: string): void {
+    this.setDataFrame(DG.DataFrame.fromCsv(str));
+  }
 
   get placeholdersValue(): PolyToolPlaceholder[] {
     return dfToPlaceholders(this.grid.dataFrame);
   }
 
   private readonly gridHost: HTMLDivElement;
-  public readonly grid: DG.Grid;
+  private grid!: DG.Grid;
 
   private subs: Unsubscribable[] = [];
 
-  protected constructor(name: string | undefined, grid: DG.Grid, heightRowCount?: number) {
+  protected constructor(
+    private readonly name: string | undefined,
+    heightRowCount?: number, options?: {},
+  ) {
     super();
 
-    if (name) this.captionLabel.innerText = name;
-
-    this.gridHost = ui.div([], {
+    this.caption = name ?? '';
+    this.root.classList.add('ui-input-polytool-pos-grid');
+    this.root.append(this.gridHost = ui.div([], {
       classes: 'ui-input-editor',
       style: {width: '100%', height: '100%', marginTop: '-8px', marginBottom: '8px', paddingBottom: '4px'},
+    }));
+    this.render(heightRowCount, options).then(() => {});
+  }
+
+  detach(): void {
+    for (const sub of this.subs) sub.unsubscribe();
+    for (const sub of this.dataFrameSubs) sub.unsubscribe();
+  }
+
+  async render(heightRowCount?: number, options?: {}): Promise<void> {
+    // this.captionLabel.appendChild(ui.divH([ui.divText(this.name ?? this.caption), ui.icons.add(() => {}, 'Add')]));
+    let removeCol: DG.Column<boolean>;
+    const df: DG.DataFrame = DG.DataFrame.fromColumns([
+      removeCol = DG.Column.fromType(DG.COLUMN_TYPE.STRING, 'Remove', 0),
+      DG.Column.fromType(DG.COLUMN_TYPE.INT, 'Position', 0),
+      DG.Column.fromType(DG.COLUMN_TYPE.STRING, 'Monomers', 0),])!;
+    removeCol.setTag(DG.TAGS.FRIENDLY_NAME, '');
+    this.grid = (await df.plot.fromType(DG.VIEWER.GRID, options)) as DG.Grid;
+    this.grid.sort(['Position']);
+    this.grid.columns.byIndex(1)!.width = this.grid.props.rowHeight + 2;
+
+    this.grid.onCellRender.subscribe((eventArgs: GridCellRenderArgs) => {
+      const gridCell = eventArgs.cell;
+      if (gridCell.tableColumn?.name == removeCol.name && (gridCell?.tableRowIndex ?? -1) >= 0) {
+        gridCell.element = ui.div(ui.icons.delete(() => {
+          this.grid.dataFrame.rows.removeAt(gridCell.tableRowIndex!);
+        }, 'Delete'), {
+          style: {
+            height: `${gridCell.grid.props.rowHeight}px`, color: 'var(--grey-6)',
+            display: 'flex', flexDirection: 'row', justifyContent: 'center'
+          }
+        });
+      }
     });
 
-    this.grid = grid;
-    this.gridHost.append(this.grid.root);
+    this.updateGridHeight(heightRowCount ?? this.grid.dataFrame.rowCount + 0.7);
+    this.subs.push(ui.onSizeChanged(this.grid.root)
+      .subscribe(this.gridRootOnSizeChanged.bind(this)));
+    this.subs.push(fromEvent<KeyboardEvent>(this.grid.root, 'keydown')
+      .subscribe((e: KeyboardEvent) => {
+        if (e.key === 'Enter') e.stopPropagation();
+      }));
+    this.setDataFrame(df);
 
-    if (heightRowCount != null) {
-      this.updateGridHeight(heightRowCount + 0.7);
-    } else {
-      this.updateGridHeight(this.grid.dataFrame.rowCount + 0.6);
-      this.subs.push(this.grid.dataFrame.onRowsAdded
-        .subscribe(() => { this.updateGridHeight(this.grid.dataFrame.rowCount + 0.6); }));
-    }
     this.grid.root.style.width = `100%`;
+    this.gridHost.append(this.grid.root);
+  }
 
-    this.subs.push(this.grid.dataFrame.onDataChanged.subscribe(() => {
-      this.fireChanged();
-    }));
+  private dataFrameSubs: Unsubscribable[] = [];
+
+  private setDataFrame(dataFrame: DG.DataFrame): void {
+    for (const sub of this.dataFrameSubs) sub.unsubscribe();
+    this.grid.dataFrame = dataFrame;
 
-    this.subs.push(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.dataFrameSubs.push(this.grid.dataFrame.onRowsRemoved
+      .subscribe(() => {
+        this.updateGridHeight(this.grid.dataFrame.rowCount + 0.7);
+        this.fireChanged();
+      }));
+    this.dataFrameSubs.push(this.grid.dataFrame.onRowsAdded
+      .subscribe(() => { this.updateGridHeight(this.grid.dataFrame.rowCount + 0.7); }));
+    this.dataFrameSubs.push(this.grid.dataFrame.onDataChanged.subscribe(() => {
+      this.fireChanged();
     }));
 
-    this.root.classList.add('ui-input-polytool-pos-grid');
-    this.root.append(this.gridHost);
+    this.updateGridHeight(this.grid.dataFrame.rowCount + 0.7);
+    this.fireChanged();
   }
 
-  detach(): void {
-    for (const sub of this.subs) sub.unsubscribe();
+  /** @param {number} posOutIdx continuous (outer) position index, 0-based */
+  addPosition(posOutIdx: number): void {
+    const phDf = this.grid.dataFrame;
+    const posList = phDf.columns.byName('Position').toList();
+    let rowIdx = posList.indexOf(posOutIdx + 1);
+    if (rowIdx === -1) {
+      rowIdx = posList.findIndex((v) => isNaN(v));
+      if (rowIdx === -1)
+        rowIdx = phDf.rows.addNew(['', posOutIdx + 1, '']).idx;
+      const tgtCell = this.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;
   }
 
   public static async create(
     name?: string, options?: {}, heightRowCount?: number
   ): Promise<PolyToolPlaceholdersInput> {
-    const df: DG.DataFrame = DG.DataFrame.fromColumns([
-      DG.Column.fromType(DG.COLUMN_TYPE.INT, 'Position', 0),
-      DG.Column.fromType(DG.COLUMN_TYPE.STRING, 'Monomers', 0),])!;
-    const grid = (await df.plot.fromType(DG.VIEWER.GRID, options)) as DG.Grid;
-    grid.sort(['Position']);
-    return new PolyToolPlaceholdersInput(name, grid, heightRowCount);
+    return new PolyToolPlaceholdersInput(name, heightRowCount, options);
   }
 
   // -- Update view --
@@ -90,8 +148,9 @@ export class PolyToolPlaceholdersInput extends DG.JsInputBase<DG.DataFrame> {
   // -- Handle events --
 
   private gridRootOnSizeChanged(): void {
-    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.grid.columns.byIndex(3)!.width = this.grid.root.clientWidth - this.grid.horzScroll.root.offsetWidth -
+      this.grid.columns.byIndex(0)!.width - this.grid.columns.byIndex(1)!.width -
+      this.grid.columns.byIndex(2)!.width - 10;
   }
 }
 
@@ -111,6 +170,8 @@ export function getPlaceholdersFromText(src: string): PolyToolPlaceholder[] {
 export function dfToPlaceholders(df: DG.DataFrame): PolyToolPlaceholder[] {
   const res: PolyToolPlaceholder[] = [];
   for (let rowI = 0; rowI < df.rowCount; rowI++) {
+    if (df.getCol('Position').isNone(rowI))
+      continue;
     const pos = parseInt(df.get('Position', rowI)) - 1;
     if (!isNaN(pos)) {
       const monomerSymbolList = parseMonomerSymbolList(df.get('Monomers', rowI));

package/src/polytool/pt-unrule-dialog.ts

@@ -10,7 +10,7 @@ import {getHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 
 import {defaultErrorHandler} from '../utils/err-info';
 import {doPolyToolUnrule} from './pt-unrule';
-import {getRules, RuleInputs, RULES_PATH, RULES_STORAGE_NAME} from './pt-rules';
+import {getRules, RuleInputs, RULES_PATH, RULES_STORAGE_NAME} from './conversion/pt-rules';
 import {PT_ERROR_DATAFRAME, PT_UI_DIALOG_UNRULE, PT_UI_RULES_USED} from './const';
 
 import {_package} from '../package';

package/src/polytool/pt-unrule.ts

@@ -4,9 +4,9 @@ import * as DG from 'datagrok-api/dg';
 
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
 
-import {Chain} from './pt-conversion';
+import {Chain} from './conversion/pt-chain';
 import {getPolyToolUnruleDialog} from './pt-unrule-dialog';
-import {Rules} from './pt-rules';
+import {Rules} from './conversion/pt-rules';
 
 import {_package} from '../package';
 import {IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';

package/src/polytool/types.ts

@@ -13,7 +13,11 @@ export type PolyToolEnumeratorType = typeof PolyToolEnumeratorTypes[keyof typeof
 
 export type PolyToolPlaceholder = { position: number, monomers: string[] };
 
-export type PolyToolBreadthPlaceholder = { start: number, end: number, monomers: string[] };
+export type PolyToolBreadthPlaceholder = {
+  /** 0-based monomer position index */ start: number,
+  /** 0-based monomer position index */ end: number,
+  monomers: string[]
+};
 
 export type PolyToolEnumeratorParams = {
   type: PolyToolEnumeratorType;

package/src/tests/polytool-chain-from-notation-tests.ts

@@ -3,8 +3,8 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {before, after, category, expect, test, expectArray, testEvent, delay} from '@datagrok-libraries/utils/src/test';
-import {Chain} from '../polytool/pt-conversion';
-import {getRules} from '../polytool/pt-rules';
+import {Chain} from '../polytool/conversion/pt-chain';
+import {getRules} from '../polytool/conversion/pt-rules';
 import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 
 category('PolyTool: Chain', () => {
@@ -23,7 +23,7 @@ category('PolyTool: Chain', () => {
       },
       tgt: {
         templateChain: {monomerCount: [11], linkageCount: 0},
-        mmChain: {monomerCount: [11], linkageCount: 1,}
+        mmChain: {monomerCount: [11], linkageCount: 1}
       },
     },
     'reaction1': {
@@ -54,15 +54,11 @@ category('PolyTool: Chain', () => {
         templateHelm: 'PEPTIDE1{[(#3)Succ]}' + '|' +
           'PEPTIDE2{[A(CHOL)].F.[C(1)].T.G.H.Y.P.[C(1)].[NH2]}' + '$' +
           'PEPTIDE1,PEPTIDE2,1:R1-1:R1' + '$$$' + 'V2.0',
-        mmHelm: 'PEPTIDE1{[Succ].[A(CHOL)].F.C.T.G.H.Y.P.C.[NH2]}' + '|' +
-          'PEPTIDE2{[A(CHOL)].F.C.T.G.H.Y.P.C.[NH2]}' + '$' +
-          'PEPTIDE1,PEPTIDE2,1:R1-1:R1' + '|' +
-          'PEPTIDE1,PEPTIDE1,4:R3-10:R3' + '|' +
-          'PEPTIDE2,PEPTIDE2,3:R3-9:R3' + '$$$V2.0',
+        mmHelm: 'PEPTIDE1{[(#3)Succ].[{A(CHOL)].F.C.T.G.H.Y.P.C.[NH2}]}$PEPTIDE1,PEPTIDE1,4:R3-10:R3$$$V2.0',
       },
       tgt: {
         templateChain: {monomerCount: [1, 10], linkageCount: 1},
-        mmChain: {monomerCount: [11, 10], linkageCount: 3,}
+        mmChain: {monomerCount: [11], linkageCount: 1}
       }
     },
     'dimerized2': {
@@ -72,15 +68,11 @@ category('PolyTool: Chain', () => {
           'PEPTIDE2{R.F.[C(1)].T.G.H.F.P.[C(1)].[NH2]}' + '|' +
           'PEPTIDE3{[($3)A(CHOL)].F.[C(1)].Y.H.G.D.N.[C(1)].[meI]}' + '$' +
           'PEPTIDE1,PEPTIDE2,1:R1-1:R1' + '$$$' + 'V2.0',
-        mmHelm: 'PEPTIDE1{[Succ].R.F.C.T.G.H.F.P.C.[NH2]}' + '|' +
-          'PEPTIDE2{[A(CHOL)].F.C.Y.H.G.D.N.C.[meI]}' + '$' +
-          'PEPTIDE1,PEPTIDE2,1:R1-1:R1' + '|' +
-          'PEPTIDE1,PEPTIDE1,4:R3-10:R3' + '|' +
-          'PEPTIDE2,PEPTIDE2,3:R3-9:R3' + '$$$V2.0',
+        mmHelm: 'PEPTIDE1{[($3)Succ].[{R].F.C.T.G.H.F.P.C.[NH2}($3){A(CHOL)].F.[C(1)].Y.H.G.D.N.[C(1)].[meI}]}$PEPTIDE1,PEPTIDE1,4:R3-10:R3$$$V2.0',
       },
       tgt: {
-        templateChain: {monomerCount: [1, 10, 10], linkageCount: 1,},
-        mmChain: {monomerCount: [11, 10], linkageCount: 3,}
+        templateChain: {monomerCount: [1, 10, 10], linkageCount: 1},
+        mmChain: {monomerCount: [20], linkageCount: 1}
       }
     }
   };
@@ -124,12 +116,11 @@ category('PolyTool: Chain', () => {
     test(`applyRules-${testName}`, async () => {
       const rules = await getRules(['rules_example.json']);
       const resTemplateChain = Chain.parseNotation(data.templateSeq, helmHelper);
-      const resMmChain = resTemplateChain.applyRules(rules);
+      const resMmChain = await resTemplateChain.applyRules(rules);
       resMmChain.check(true);
       expectArray(resMmChain.monomers.map((mL) => mL.length), tgt.mmChain.monomerCount);
       expect(resMmChain.linkages.length, tgt.mmChain.linkageCount);
       expect(resMmChain.getHelm(), data.mmHelm);
     }, {skipReason: 'applyRules is not implemented'});
   }
-
 });

package/src/tests/polytool-chain-parse-notation-tests.ts

@@ -3,8 +3,9 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {before, after, category, expect, test, expectArray, testEvent, delay} from '@datagrok-libraries/utils/src/test';
-import {Chain, getInnerIdx, getOuterIdx} from '../polytool/pt-conversion';
-import {getRules} from '../polytool/pt-rules';
+import {Chain} from '../polytool/conversion/pt-chain';
+import {getInnerIdx, getOuterIdx} from '../polytool/conversion/pt-misc';
+import {getRules} from '../polytool/conversion/pt-rules';
 import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 
 category('PolyTool: Chain: parseNotation', () => {

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

@@ -2,7 +2,8 @@ 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, testEvent, delay, expectObject} from '@datagrok-libraries/utils/src/test';
+import {before, after, category, expect, test, expectArray, testEvent, expectObject}
+  from '@datagrok-libraries/utils/src/test';
 import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 import {
@@ -14,8 +15,9 @@ import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
 import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
 import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 
-import {doPolyToolConvert, getOverriddenLibrary} from '../polytool/pt-conversion';
-import {getRules} from '../polytool/pt-rules';
+import {doPolyToolConvert} from '../polytool/conversion/pt-conversion';
+import {getOverriddenLibrary} from '../polytool/conversion/pt-misc';
+import {getRules} from '../polytool/conversion/pt-rules';
 
 
 import {_package} from '../package-test';

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

@@ -5,6 +5,6 @@ import * as DG from 'datagrok-api/dg';
 import {before, after, category, expect, test, expectArray, testEvent, delay} from '@datagrok-libraries/utils/src/test';
 
 import {doPolyToolUnrule} from '../polytool/pt-unrule';
-import {getRules} from '../polytool/pt-rules';
+import {getRules} from '../polytool/conversion/pt-rules';
 
 import {_package} from '../package-test';

package/src/tests/toAtomicLevel-tests.ts

@@ -15,8 +15,8 @@ import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
 import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
 
 import {_package} from '../package-test';
-import {getNewMonomer} from '../polytool/pt-conversion';
-import {getRules, RuleReaction} from '../polytool/pt-rules';
+import {getNewMonomers} from '../polytool/conversion/pt-misc';
+import {getRules, RuleReaction} from '../polytool/conversion/pt-rules';
 
 category('toAtomicLevel', () => {
   let userLibSettings: UserLibSettings;
@@ -24,7 +24,6 @@ category('toAtomicLevel', () => {
   let rdKitModule: RDModule;
 
   before(async () => {
-
     monomerLibHelper = await getMonomerLibHelper();
     userLibSettings = await getUserLibSettings();
     rdKitModule = await getRdKitModule();
@@ -79,10 +78,10 @@ category('toAtomicLevel', () => {
     const rules = await getRules(['rules_example.json']);
     const reactionRule = rules.reactionRules.find((r) => r.name == 'GGaz')!;
 
-    const [newSymbol, newMonomer] = getNewMonomer(rdKitModule, systemMonomerLib, reactionRule);
-    expect(newSymbol, reactionRule.name);
+    const [newSymbols, newMonomers] = getNewMonomers(rdKitModule, systemMonomerLib, reactionRule);
+    expect(newSymbols[0], reactionRule.name);
 
-    const mol = rdKitModule.get_mol(newMonomer.molfile);
+    const mol = rdKitModule.get_mol(newMonomers[0].molfile);
     try {
       const molInchi = mol.get_inchi();
       const molInchiKey = rdKitModule.get_inchikey_for_inchi(molInchi);

package/src/utils/cell-renderer-cyclized.ts

@@ -0,0 +1,37 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {MonomerPlacer} from '@datagrok-libraries/bio/src/utils/cell-renderer-monomer-placer';
+import {monomerToShort} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
+
+import {_package} from '../package';
+
+export class CyclizedCellRendererBack extends MonomerPlacer {
+
+  constructor(
+    gridCol: DG.GridColumn | null, tableCol: DG.Column,
+    maxLengthOfMonomer: number, seqHelper: ISeqHelper
+  ) {
+    super(gridCol, tableCol, _package.logger, maxLengthOfMonomer, () => {
+      const sh = seqHelper.getSeqHandler(tableCol);
+      return {
+        seqHandler: sh,
+        monomerCharWidth: 7,
+        separatorWidth: 11,
+        monomerToShort: monomerToShort,
+      };
+    });
+  }
+
+  override onMouseMove(gridCell: DG.GridCell, e: MouseEvent) {
+    const gridCellBounds: DG.Rect = gridCell.bounds;
+    const argsX = e.offsetX - gridCell.gridColumn.left + (gridCell.gridColumn.left - gridCellBounds.x);
+    const left: number | null = this.getPosition(gridCell.tableRowIndex!, argsX, gridCellBounds.width);
+    if(left != null) {
+
+    }
+    super.onMouseMove(gridCell, e);
+  }
+}

package/src/utils/context-menu.ts

@@ -3,7 +3,7 @@ import * as DG from 'datagrok-api/dg';
 import * as ui from 'datagrok-api/ui';
 
 import {defaultErrorHandler} from './err-info';
-import {polyToolEnumerateHelmUI} from '../polytool/pt-enumeration-helm-dialog';
+import {polyToolEnumerateHelmUI} from '../polytool/pt-enumerate-seq-dialog';
 import {polyToolEnumerateChemUI} from '../polytool/pt-dialog';
 
 import {_package} from '../package';