@datagrok/bio 2.12.11 → 2.12.13

package/package.json

@@ -5,7 +5,7 @@
     "name": "Aleksandr Tanas",
     "email": "atanas@datagrok.ai"
   },
-  "version": "2.12.11",
+  "version": "2.12.13",
   "description": "Bioinformatics support (import/export of sequences, conversion, visualization, analysis). [See more](https://github.com/datagrok-ai/public/blob/master/packages/Bio/README.md) for details.",
   "repository": {
     "type": "git",
@@ -34,12 +34,12 @@
   ],
   "dependencies": {
     "@biowasm/aioli": "^3.1.0",
-    "@datagrok-libraries/bio": "^5.40.6",
-    "@datagrok-libraries/chem-meta": "^1.2.3",
-    "@datagrok-libraries/ml": "^6.5.1",
+    "@datagrok-libraries/bio": "^5.40.8",
+    "@datagrok-libraries/chem-meta": "^1.2.5",
+    "@datagrok-libraries/math": "^1.1.1",
+    "@datagrok-libraries/ml": "^6.6.0",
     "@datagrok-libraries/tutorials": "^1.3.12",
     "@datagrok-libraries/utils": "^4.2.0",
-    "@datagrok-libraries/math": "^1.0.8",
     "@webgpu/types": "^0.1.40",
     "ajv": "^8.12.0",
     "ajv-errors": "^3.0.0",
@@ -103,7 +103,8 @@
     "All users"
   ],
   "sources": [
-    "css/helm.css"
+    "css/helm.css",
+    "common/openchemlib-full.js"
   ],
   "category": "Bioinformatics",
   "meta": {

package/src/package.ts

@@ -1,4 +1,4 @@
-/* Do not change these import lines to match external modules in webpack configuration */
+/* eslint max-lines: "off" */
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
@@ -486,7 +486,7 @@ export async function activityCliffs(table: DG.DataFrame, molecules: DG.Column<s
 //meta.supportedSemTypes: Macromolecule
 //meta.supportedTypes: string
 //meta.supportedUnits: fasta,separator,helm
-//meta.supportedDistanceFunctions: Levenshtein,Hamming,Monomer chemical distance,Needlemann-Wunsch
+//meta.supportedDistanceFunctions: Hamming,Levenshtein,Monomer chemical distance,Needlemann-Wunsch
 //input: column col {semType: Macromolecule}
 //input: string metric
 //input: double gapOpen = 1 {caption: Gap open penalty; default: 1; optional: true}

package/src/tests/renderers-test.ts

@@ -1,7 +1,11 @@
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
+import * as ui from 'datagrok-api/ui';
 
-import {category, expect, test, delay} from '@datagrok-libraries/utils/src/test';
+import $ from 'cash-dom';
+import {fromEvent} from 'rxjs';
+
+import {category, expect, test, delay, testEvent} from '@datagrok-libraries/utils/src/test';
 import {ALIGNMENT, ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 
@@ -12,6 +16,8 @@ import {multipleSequenceAlignmentUI} from '../utils/multiple-sequence-alignment-
 import {awaitGrid} from './utils';
 import * as C from '../utils/constants';
 
+import {_package} from '../package-test';
+
 category('renderers', () => {
   test('long sequence performance ', async () => {
     await performanceTest(generateLongSequence, 'Long sequences');
@@ -48,6 +54,10 @@ category('renderers', () => {
     await _selectRendererBySemType();
   });
 
+  test('scatterPlotTooltip', async () => {
+    await _testScatterPlotTooltip();
+  });
+
   async function _rendererMacromoleculeFasta() {
     const csv: string = await grok.dapi.files.readAsText('System:AppData/Bio/samples/FASTA.csv');
     const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
@@ -197,4 +207,40 @@ category('renderers', () => {
         `view renderer has set to '${renderer}' instead of correct 'MacromoleculeDifference'.`);
     }
   }
+
+  const seqCoordsCsv = `seq,x,y
+ACGGTGTCGT,0,0
+CGGTATCCCT,1,0
+CTCGGCATGC,2,0
+`;
+
+  async function _testScatterPlotTooltip(): Promise<void> {
+    const df = DG.DataFrame.fromCsv(seqCoordsCsv);
+    df.currentRowIdx = 0;
+    const view = grok.shell.addTableView(df);
+    const sp: DG.ScatterPlotViewer = df.plot.scatter({x: 'x', y: 'y'});
+    view.dockManager.dock(sp, DG.DOCK_TYPE.RIGHT, null);
+    await Promise.all([
+      testEvent(sp.onAfterDrawScene, () => {}, () => { sp.invalidateCanvas(); }, 1000),
+      awaitGrid(view.grid, 500)
+    ]);
+
+    const spBcr = sp.root.getBoundingClientRect();
+    const wp = sp.worldToScreen(1, 0);
+    const ev = new MouseEvent('mousemove', {
+      cancelable: true, bubbles: true, view: window, button: 0,
+      clientX: spBcr.left + wp.x, clientY: spBcr.top + wp.y
+    });
+    const spCanvas = $(sp.root).find('canvas').get()[0] as HTMLCanvasElement;
+    await testEvent(fromEvent(spCanvas, 'mousemove'), () => {
+      _package.logger.debug(`Test: event, currentRowIdx=${df.currentRowIdx}`);
+      expect($(ui.tooltip.root).find('div table.d4-row-tooltip-table tr td canvas').length, 1);
+      expect(sp.hitTest(wp.x, wp.y), 1);
+    }, () => {
+      spCanvas.dispatchEvent(ev);
+    }, 500);
+    // TODO: Any error occurred become 'Cannot read properties of null (reading 'get$columns')' because of scatter plot
+    //await testEvent(sp.onAfterDrawScene, () => {}, () => { sp.invalidateCanvas(); }, 200);
+    await awaitGrid(view.grid, 500);
+  }
 });

package/src/utils/cell-renderer.ts

@@ -59,6 +59,31 @@ export function processSequence(subParts: string[]): [string[], boolean] {
   return [text, simplified];
 }
 
+type RendererGridCellTemp = {
+  [mmcrTemps.monomerPlacer]: MonomerPlacer
+}
+
+function getRendererFridCellTempTemp(gridCell: DG.GridCell): RendererGridCellTemp {
+  /** Primarily store/get MonomerPlacer at GridColumn, fallback at (Table) Column for scatter plot tooltip  */
+  let temp: RendererGridCellTemp | null = null;
+
+  let gridCol: DG.GridColumn | null = null;
+  try { gridCol = gridCell.gridColumn; } catch { gridCol = null; }
+  temp = gridCol && gridCol.dart ? gridCol.temp as RendererGridCellTemp : null;
+
+  if (!temp) {
+    let tableCol: DG.Column | null = null;
+    try { tableCol = gridCell.cell.column; } catch { tableCol = null; }
+    if (!tableCol) {
+      const k = 42;
+    }
+    temp = tableCol ? tableCol.temp as RendererGridCellTemp : null;
+  }
+  if (temp === null)
+    throw new Error(`Monomer placer store (GridColumn or Column) not found.`);
+  return temp;
+}
+
 export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
   private padding: number = 5;
 
@@ -82,7 +107,7 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
 
     const tableCol: DG.Column = gridCell.cell.column;
     //const tableColTemp: TempType = tableCol.temp;
-    const seqColTemp: MonomerPlacer = gridCell.gridColumn.temp[mmcrTemps.monomerPlacer];
+    const seqColTemp: MonomerPlacer = getRendererFridCellTempTemp(gridCell)[mmcrTemps.monomerPlacer];
     if (!seqColTemp) return; // Can do nothing without precalculated data
 
     const gridCellBounds: DG.Rect = gridCell.bounds;
@@ -165,7 +190,7 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
         (!isNaN(tagMaxMonomerLength) ? tagMaxMonomerLength : _package.properties?.MaxMonomerLength) ?? 4;
     }
 
-    let seqColTemp: MonomerPlacer = gridCell.gridColumn.temp[mmcrTemps.monomerPlacer];
+    let seqColTemp: MonomerPlacer = getRendererFridCellTempTemp(gridCell)[mmcrTemps.monomerPlacer];
     if (!seqColTemp) {
       seqColTemp = new MonomerPlacer(grid, tableCol,
         () => {
@@ -192,7 +217,7 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
     const _maxIndex = maxLengthWords.length;
 
     // Store updated seqColTemp to the col temp
-    if (seqColTemp.updated) gridCell.gridColumn.temp[mmcrTemps.monomerPlacer] = seqColTemp;
+    if (seqColTemp.updated) getRendererFridCellTempTemp(gridCell)[mmcrTemps.monomerPlacer] = seqColTemp;
 
     g.save();
     try {

package/src/utils/helm-to-molfile/converter/connection-list.ts

@@ -0,0 +1,40 @@
+import {HELM_POLYMER_TYPE} from '@datagrok-libraries/bio/src/utils/const';
+import {HELM_ITEM_SEPARATOR} from './const';
+import {Bond} from './types';
+
+export class ConnectionList {
+  constructor(connectionList: string) {
+    const splitted = connectionList.split(HELM_ITEM_SEPARATOR);
+    splitted.forEach((connectionItem: string) => this.validateConnectionItem(connectionItem));
+    this.connectionItems = splitted;
+  }
+
+  private connectionItems: string[];
+
+  private validateConnectionItem(connectionItem: string): void {
+    const allowedType = `(${HELM_POLYMER_TYPE.PEPTIDE}|${HELM_POLYMER_TYPE.RNA})`;
+    const regex = new RegExp(`${allowedType}[0-9]+,${allowedType}[0-9]+,[0-9]+:R[0-9]+-[0-9]+:R[0-9]+`, 'g');
+    if (!connectionItem.match(regex))
+      throw new Error(`Cannot parse connection item from ${connectionItem}`);
+  }
+
+  getConnectionData(): {polymerId: string, bond: Bond}[][] {
+    const result: {polymerId: string, bond: Bond}[][] = [];
+    this.connectionItems.forEach((connectionItem: string) => {
+      const pair: {polymerId: string, bond: Bond}[] = [];
+      const splitted = connectionItem.split(',');
+      splitted[2].split('-').forEach((item, idx) => {
+        const polymerId = splitted[idx];
+        const data = item.split(':');
+        // WARNING: monomer idx starts from 0
+        const monomerIdx = parseInt(data[0]) - 1;
+        const rGroupId = parseInt(data[1].slice(1));
+        const bondData = {monomerIdx, rGroupId};
+        pair.push({polymerId, bond: bondData});
+      });
+      result.push(pair);
+    });
+    return result;
+  }
+}
+

package/src/utils/helm-to-molfile/converter/const.ts

@@ -0,0 +1,4 @@
+export const HELM_ITEM_SEPARATOR = '|';
+export const HELM_SECTION_SEPARATOR = '$';
+
+export const HYDROGEN_SYMBOL = 'H';

package/src/utils/helm-to-molfile/converter/converter.ts

@@ -0,0 +1,124 @@
+/* Do not change these import lines to match external modules in webpack configuration */
+import * as DG from 'datagrok-api/dg';
+import * as grok from 'datagrok-api/grok';
+import * as OCL from 'openchemlib/full';
+
+import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
+import {RDModule, RDMol} from '@datagrok-libraries/chem-meta/src/rdkit-api';
+import {_package} from '../../../package';
+import {Polymer} from './polymer';
+import {GlobalMonomerPositionHandler} from './position-handler';
+
+export class HelmToMolfileConverter {
+  constructor(private helmColumn: DG.Column<string>, private df: DG.DataFrame) {
+    this.helmColumn = helmColumn;
+  }
+
+  async convertToSmiles(): Promise<DG.Column<string>> {
+    const smiles = await this.getSmilesList();
+    const columnName = this.df.columns.getUnusedName(`smiles(${this.helmColumn.name})`);
+    return DG.Column.fromStrings(columnName, smiles.map((molecule) => {
+      if (molecule === null)
+        return '';
+      return molecule;
+    }));
+  }
+
+  private async getSmilesList(): Promise<string[]> {
+    const molfilesV2K = (await this.convertToMolfileV2KColumn()).toList();
+    const smiles = molfilesV2K.map((mol) => DG.chem.convert(mol, DG.chem.Notation.MolBlock, DG.chem.Notation.Smiles));
+    return smiles;
+  }
+
+  private async getMolV3000ViaOCL(beautifiedMols: (RDMol | null)[], columnName: string) {
+    const beautifiedMolV2000 = beautifiedMols.map((mol) => {
+      if (mol === null)
+        return '';
+      const molBlock = mol.get_molblock();
+      mol!.delete();
+      return molBlock;
+    });
+    const molv3000Arr = new Array<string>(beautifiedMolV2000.length);
+    const chiralityPb = DG.TaskBarProgressIndicator.create(`Handling chirality...`);
+    for (let i = 0; i < beautifiedMolV2000.length; i++) {
+      const oclMolecule = OCL.Molecule.fromMolfile(beautifiedMolV2000[i]);
+      const molV3000 = oclMolecule.toMolfileV3();
+      molv3000Arr[i] = molV3000.replace('STERAC1', 'STEABS');
+      const progress = i / beautifiedMolV2000.length * 100;
+      chiralityPb.update(progress, `${progress?.toFixed(2)}% of molecules completed`);
+    }
+    chiralityPb.close();
+    return DG.Column.fromStrings(columnName, molv3000Arr);
+  }
+
+  async convertToRdKitBeautifiedMolfileColumn(chiralityEngine?: boolean): Promise<DG.Column<string>> {
+    const smiles = await this.getSmilesList();
+    const rdKitModule: RDModule = await grok.functions.call('Chem:getRdKitModule');
+    const beautifiedMols = smiles.map((item) =>{
+      if (item === '')
+        return null;
+      const mol = rdKitModule.get_mol(item);
+      if (!mol)
+        return null;
+      mol.normalize_depiction(1);
+      mol.straighten_depiction(true);
+      return mol;
+    });
+    const columnName = this.df.columns.getUnusedName(`molfile(${this.helmColumn.name})`);
+
+    if (chiralityEngine)
+      return await this.getMolV3000ViaOCL(beautifiedMols, columnName);
+    return DG.Column.fromStrings(columnName, beautifiedMols.map((mol) => {
+      if (mol === null)
+        return '';
+      const molBlock = mol.get_v3Kmolblock();
+      mol!.delete();
+      return molBlock;
+    }));
+  }
+
+  private async convertToMolfileV2KColumn(): Promise<DG.Column<string>> {
+    const polymerGraphColumn: DG.Column<string> = await this.getPolymerGraphColumn();
+    const rdKitModule = await grok.functions.call('Chem:getRdKitModule');
+    const molfileList = polymerGraphColumn.toList().map(
+      (pseudoMolfile: string, idx: number) => {
+        const helm = this.helmColumn.get(idx);
+        if (!helm)
+          return '';
+        let result = '';
+        try {
+          result = this.getPolymerMolfile(helm, pseudoMolfile, rdKitModule);
+        } catch (err: any) {
+          const [errMsg, errStack] = errInfo(err);
+          _package.logger.error(errMsg, undefined, errStack);
+        } finally {
+          return result;
+        }
+      });
+    const molfileColName = this.df.columns.getUnusedName(`molfileV2K(${this.helmColumn.name})`);
+    const molfileColumn = DG.Column.fromList('string', molfileColName, molfileList);
+    return molfileColumn;
+  }
+
+  private async getPolymerGraphColumn(): Promise<DG.Column<string>> {
+    const polymerGraphColumn: DG.Column<string> =
+      await grok.functions.call('HELM:getMolfiles', {col: this.helmColumn});
+    return polymerGraphColumn;
+  }
+
+  private getPolymerMolfile(
+    helm: string,
+    polymerGraph: string,
+    rdKitModule: RDModule
+  ): string {
+    const globalPositionHandler = new GlobalMonomerPositionHandler(polymerGraph);
+    const polymer = new Polymer(helm, rdKitModule);
+    globalPositionHandler.monomerSymbols.forEach((monomerSymbol: string, monomerIdx: number) => {
+      const shift = globalPositionHandler.getMonomerShifts(monomerIdx);
+      polymer.addMonomer(monomerSymbol, monomerIdx, shift);
+    });
+    const polymerMolfile = polymer.compileToMolfile();
+    return polymerMolfile;
+  }
+}
+

package/src/utils/helm-to-molfile/converter/helm.ts

@@ -0,0 +1,112 @@
+import {HELM_POLYMER_TYPE} from '@datagrok-libraries/bio/src/utils/const';
+import {ConnectionList} from './connection-list';
+import {HELM_ITEM_SEPARATOR, HELM_SECTION_SEPARATOR} from './const';
+import {SimplePolymer} from './simple-polymer';
+import {Bond} from './types';
+
+export class Helm {
+  constructor(private helmString: string) {
+    const helmSections = this.helmString.split(HELM_SECTION_SEPARATOR);
+    const simplePolymers = helmSections[0].split(HELM_ITEM_SEPARATOR);
+    this.simplePolymers = simplePolymers
+      .map((item) => new SimplePolymer(item));
+    if (helmSections[1] !== '')
+      this.connectionList = new ConnectionList(helmSections[1]);
+    this.bondData = this.getBondData();
+
+    this.bondedRGroupsMap = this.getBondedRGroupsMap();
+  }
+
+  /** List of pairs for bonded monomers, monomers indexed globally (withing the
+   * complex polymer scope) */
+  readonly bondData: Bond[][];
+
+  private simplePolymers: SimplePolymer[];
+  private connectionList?: ConnectionList;
+
+  /** Maps global monomer index to r-group ids (starting from 1) participating
+   * in connection */
+  readonly bondedRGroupsMap: Map<number, number[]>;
+
+  private getBondedRGroupsMap(): Map<number, number[]> {
+    const bondedRGroupsMap = new Map<number, number[]>();
+    this.bondData.forEach((bond) => {
+      bond.forEach((bondPart) => {
+        const monomerIdx = bondPart.monomerIdx;
+        const rGroupId = bondPart.rGroupId;
+        if (!bondedRGroupsMap.get(monomerIdx))
+          bondedRGroupsMap.set(monomerIdx, []);
+        bondedRGroupsMap.get(monomerIdx)!.push(rGroupId);
+      });
+    });
+
+    return bondedRGroupsMap;
+  }
+
+  toString() {
+    return this.helmString;
+  }
+
+  getPolymerTypeByMonomerIdx(monomerGlobalIdx: number): HELM_POLYMER_TYPE {
+    const simplePolymer = this.getSimplePolymerByMonomerIdx(monomerGlobalIdx);
+    const polymerType = simplePolymer.polymerType;
+    return polymerType as HELM_POLYMER_TYPE;
+  }
+
+  private getSimplePolymerByMonomerIdx(monomerGlobalIdx: number): SimplePolymer {
+    const shifts = this.getMonomerIdxShifts();
+    const shiftValues = Object.values(shifts);
+    const lowerBound = shiftValues.sort((a, b) => a - b).find(
+      (shift) => monomerGlobalIdx >= shift
+    );
+    if (lowerBound === undefined)
+      throw new Error(`Cannot find simple polymer for monomer ${monomerGlobalIdx}`);
+    const simplePolymerId = Object.keys(shifts).find((simplePolymerId) => shifts[simplePolymerId] === lowerBound)!;
+    const simplePolymer = this.simplePolymers.find((simplePolymer) => simplePolymer.id === simplePolymerId)!;
+    return simplePolymer;
+  }
+
+  private shiftBondMonomerIds(shift: number, bonds: Bond[][]): void {
+    bonds.forEach((bond) => {
+      bond.forEach((bondPart) => {
+        bondPart.monomerIdx += shift;
+      });
+    });
+  }
+
+  private getMonomerIdxShifts(): {[simplePolymerId: string]: number} {
+    const result: {[simplePolymerId: string]: number} = {};
+    let shift = 0;
+    this.simplePolymers.forEach((simplePolymer) => {
+      result[simplePolymer.id] = shift;
+      shift += simplePolymer.monomers.length;
+    });
+    return result;
+  }
+
+  private getBondData(): Bond[][] {
+    const shifts = this.getMonomerIdxShifts();
+    const result: Bond[][] = [];
+    this.simplePolymers.forEach((simplePolymer) => {
+      const bondData = simplePolymer.getBondData();
+      const shift = shifts[simplePolymer.id];
+      this.shiftBondMonomerIds(shift, bondData);
+      result.push(...bondData);
+    });
+    if (this.connectionList) {
+      const connectionData = this.connectionList.getConnectionData();
+      connectionData.forEach((connection) => {
+        const data: Bond[] = [];
+        connection.forEach((connectionItem) => {
+          const shift = shifts[connectionItem.polymerId];
+          const bond = connectionItem.bond;
+          bond.monomerIdx += shift;
+          data.push(bond);
+        });
+        result.push(data);
+      });
+    }
+    return result;
+  }
+}
+

package/src/utils/helm-to-molfile/converter/index.ts

@@ -0,0 +1 @@
+export {HelmToMolfileConverter} from './converter';

package/src/utils/helm-to-molfile/converter/mol-atoms-v2k.ts

@@ -0,0 +1,24 @@
+import {MolfileHandlerBase} from '@datagrok-libraries/chem-meta/src/parsing-utils/molfile-handler-base';
+import {MolfileAtoms} from './mol-atoms';
+
+export class MolfileAtomsV2K extends MolfileAtoms {
+  constructor(molfileHandler: MolfileHandlerBase) {
+    super();
+    this.rawAtomLines = molfileHandler.getAtomLines();
+    this.coordinates = this.rawAtomLines.map((line: string) => {
+      const x = parseFloat(line.substring(0, 10));
+      const y = parseFloat(line.substring(10, 20));
+      return {x, y};
+    });
+  }
+
+  get atomLines(): string[] {
+    return this.rawAtomLines.map((line: string, idx: number) => {
+      const coordinates = this.coordinates[idx];
+      const x = coordinates.x.toFixed(4).padStart(10, ' ');
+      const y = coordinates.y.toFixed(4).padStart(10, ' ');
+      return `${x}${y}${line.substring(20)}`;
+    });
+  }
+}
+

package/src/utils/helm-to-molfile/converter/mol-atoms-v3k.ts

@@ -0,0 +1,38 @@
+import {MolfileHandlerBase} from '@datagrok-libraries/chem-meta/src/parsing-utils/molfile-handler-base';
+import {MolfileAtoms} from './mol-atoms';
+
+const PRECISION = 6;
+
+export class MolfileAtomsV3K extends MolfileAtoms {
+  constructor(private molfileHandler: MolfileHandlerBase) {
+    super();
+    this.rawAtomLines = molfileHandler.getAtomLines();
+    this.coordinates = this.getCoordinates();
+  }
+
+  private getCoordinates(): {x: number, y: number}[] {
+    const x = this.molfileHandler.x;
+    const y = this.molfileHandler.y;
+    return Array.from(x).map((xCoord, idx) => {
+      return {x: xCoord, y: y[idx]};
+    });
+  }
+
+
+  get atomLines(): string[] {
+    // todo: optimize, optionally port to molfile-handler
+    const coordinateRegex = /^(M  V30 .*)(-?\d+\.\d+)( )(-?\d+\.\d+)( -?\d+\.\d+.*)$/;
+    const rGroupsRegex = /\sRGROUPS=\(\d+(\s+\d+)*\)/;
+
+    return this.rawAtomLines.map((line: string, idx: number) => {
+      const coordinates = this.coordinates[idx];
+      const x = coordinates.x.toFixed(PRECISION);
+      const y = coordinates.y.toFixed(PRECISION);
+
+      return line.replace(coordinateRegex, (match, p1, p2, p3, p4, p5) => {
+        return p1 + x + p3 + y + p5;
+      }).replace(rGroupsRegex, '');
+    });
+  }
+}
+

package/src/utils/helm-to-molfile/converter/mol-atoms.ts

@@ -0,0 +1,44 @@
+import {R_GROUP_ELEMENT_SYMBOL} from '@datagrok-libraries/chem-meta/src/formats/molfile-const';
+
+export abstract class MolfileAtoms {
+  protected coordinates: {x: number, y: number}[] = [];
+  protected rawAtomLines: string[] = [];
+
+  get atomCoordinates(): {x: number, y: number}[] {
+    return this.coordinates;
+  }
+
+  abstract get atomLines(): string[];
+
+  replaceRGroupSymbolByElement(atomIdx: number, newElementSymbol: string): void {
+    this.rawAtomLines[atomIdx] = this.rawAtomLines[atomIdx].replace(R_GROUP_ELEMENT_SYMBOL, newElementSymbol);
+  }
+
+  deleteAtoms(indices: number[]): void {
+    this.coordinates = this.coordinates.filter((_, idx) => !indices.includes(idx));
+    this.rawAtomLines = this.rawAtomLines.filter((_, idx) => !indices.includes(idx));
+  }
+
+  shift(shift: {x: number, y: number}): void {
+    this.coordinates = this.coordinates.map((coordinates) => {
+      const newX = coordinates.x + shift.x;
+      const newY = coordinates.y + shift.y;
+      if (isNaN(newX) || isNaN(newY))
+        throw new Error(`Cannot shift coordinates by ${shift.x}, ${shift.y}`);
+      return {x: newX, y: newY};
+    });
+  }
+
+  rotate(angle: number): void {
+    this.coordinates = this.coordinates.map((coordinates) => {
+      const x = coordinates.x;
+      const y = coordinates.y;
+      const newX = x * Math.cos(angle) - y * Math.sin(angle);
+      const newY = x * Math.sin(angle) + y * Math.cos(angle);
+      if (isNaN(newX) || isNaN(newY))
+        throw new Error(`Cannot rotate coordinates by ${angle}`);
+      return {x: newX, y: newY};
+    });
+  }
+}
+

package/src/utils/helm-to-molfile/converter/mol-bonds-v2k.ts

@@ -0,0 +1,26 @@
+import {MolfileHandlerBase} from '@datagrok-libraries/chem-meta/src/parsing-utils/molfile-handler-base';
+import {MolfileBonds} from './mol-bonds';
+
+export class MolfileBondsV2K extends MolfileBonds {
+  constructor(molfileHandler: MolfileHandlerBase) {
+    super();
+    this.rawBondLines = molfileHandler.getBondLines();
+    this.bondedAtomPairs = this.rawBondLines.map((line: string) => {
+      const firstAtom = parseInt(line.substring(0, 3));
+      const secondAtom = parseInt(line.substring(3, 6));
+      return [firstAtom, secondAtom];
+    });
+  }
+
+  /** Get bond lines with new values for bonded atoms  */
+  getBondLines(): string[] {
+    return this.bondedAtomPairs.map((bondedPair, idx) => {
+      if (bondedPair.some((atom) => atom === -1))
+        throw new Error(`Bonded pair ${bondedPair} contains -1`);
+      return `${bondedPair[0].toString().padStart(3, ' ')}${
+        bondedPair[1].toString().padStart(3, ' ')
+      }${this.rawBondLines[idx].substring(6)}`;
+    });
+  }
+}
+

package/src/utils/helm-to-molfile/converter/mol-bonds-v3k.ts

@@ -0,0 +1,30 @@
+import {MolfileHandlerBase} from '@datagrok-libraries/chem-meta/src/parsing-utils/molfile-handler-base';
+import {MolfileBonds} from './mol-bonds';
+
+export class MolfileBondsV3K extends MolfileBonds {
+  constructor(private molfileHandler: MolfileHandlerBase) {
+    super();
+    this.rawBondLines = molfileHandler.getBondLines();
+    this.bondedAtomPairs = this.getBondedAtomPairs();
+  }
+
+  private getBondedAtomPairs(): number[][] {
+    const bondedAtoms = this.molfileHandler.pairsOfBondedAtoms;
+    return bondedAtoms.map((pair) => [pair[0], pair[1]]);
+  }
+
+  /** Get bond lines with new values for bonded atoms  */
+  getBondLines(): string[] {
+    // todo: optimize
+    const regex = /^(M\s+V30\s+\d+\s+\d+\s+)(\d+)(\s+)(\d+)(.*)$/;
+    return this.bondedAtomPairs.map((bondedPair, idx) => {
+      if (bondedPair.some((atom) => atom === -1))
+        throw new Error(`Bonded pair ${bondedPair} contains -1`);
+      const result = this.rawBondLines[idx].replace(regex, (match, p1, p2, p3, p4, p5) => {
+        return `${p1}${bondedPair[0]}${p3}${bondedPair[1]}${p5}`;
+      });
+      return result;
+    });
+  }
+}
+