@datagrok/bio 2.15.2 → 2.15.5

package/src/tests/utils.ts

@@ -7,7 +7,7 @@ import {asRenderer, IRenderer, isRenderer} from '@datagrok-libraries/bio/src/typ
 import {startDockerContainer} from '../utils/docker';
 
 import {_package} from '../package-test';
-import {CellRendererBackBase, getGridCellRendererBack} from '@datagrok-libraries/bio/src/utils/cell-renderer-back-base';
+import {CellRendererBackBase, getGridCellColTemp} from '@datagrok-libraries/bio/src/utils/cell-renderer-back-base';
 
 export async function loadFileAsText(name: string): Promise<string> {
   return await _package.files.readAsText(name);
@@ -47,7 +47,7 @@ export async function awaitGrid(grid: DG.Grid, timeout: number = 5000): Promise<
     if (gridCol) {
       const gridCell = grid.cell(gridCol.name, 0);
       const [_gridCol, _tableCol, temp] =
-        getGridCellRendererBack<void, CellRendererBackBase<void>>(gridCell);
+        getGridCellColTemp<void, CellRendererBackBase<void>>(gridCell);
 
       const renderer = asRenderer(temp.rendererBack);
       if (renderer) await renderer.awaitRendered();

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

@@ -0,0 +1,62 @@
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+import * as ui from 'datagrok-api/ui';
+
+import {getGridCellColTemp, CellRendererBackBase} from '@datagrok-libraries/bio/src/utils/cell-renderer-back-base';
+import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+
+export class MacromoleculeCustomCellRenderer extends DG.GridCellRenderer {
+  get name(): string { return 'sequence'; }
+
+  get cellType(): string { return 'sequence'; }
+
+  get defaultHeight(): number | null { return 30; }
+
+  get defaultWidth(): number | null { return 230; }
+
+  getRendererBack(gridCell: DG.GridCell): CellRendererBackBase<string> {
+    const [gridCol, tableCol, temp] = getGridCellColTemp<string, any>(gridCell);
+    const sh = SeqHandler.forColumn(tableCol);
+    if (sh.notation !== NOTATION.CUSTOM)
+      throw new Error(`Unexpected notation: '${sh.notation}'.`);
+    const back = sh.getRendererBack(gridCol, tableCol);
+    return back;
+  }
+
+  override onMouseLeave(gridCell: DG.GridCell, e: MouseEvent) {
+    const back = this.getRendererBack(gridCell);
+    back.onMouseLeave(gridCell, e);
+  }
+
+  override onMouseMove(gridCell: DG.GridCell, e: MouseEvent) {
+    const back = this.getRendererBack(gridCell);
+    back.onMouseMove(gridCell, e);
+  }
+
+  override onClick(gridCell: DG.GridCell, e: MouseEvent) {
+    const back = this.getRendererBack(gridCell);
+    back.onClick(gridCell, e);
+  }
+
+  override onDoubleClick(gridCell: DG.GridCell, e: MouseEvent) {
+    const back = this.getRendererBack(gridCell);
+    back.onDoubleClick(gridCell, e);
+  }
+
+  override onKeyDown(gridCell: DG.GridCell, e: KeyboardEvent) {
+    const back = this.getRendererBack(gridCell);
+    back.onKeyDown(gridCell, e);
+  }
+
+  override onKeyPress(gridCell: DG.GridCell, e: KeyboardEvent) {
+    const back = this.getRendererBack(gridCell);
+    back.onKeyPress(gridCell, e);
+  }
+
+  override render(g: CanvasRenderingContext2D, x: number, y: number, w: number, h: number, gridCell: DG.GridCell, cellStyle: DG.GridCellStyle) {
+    const back = this.getRendererBack(gridCell);
+    back.render(g, x, y, w, h, gridCell, cellStyle);
+  }
+}
+

package/src/utils/cell-renderer.ts

@@ -8,7 +8,7 @@ import * as ui from 'datagrok-api/ui';
 import wu from 'wu';
 
 import {printLeftOrCentered, DrawStyle, TAGS as mmcrTAGS} from '@datagrok-libraries/bio/src/utils/cell-renderer';
-import {MonomerPlacer} from '@datagrok-libraries/bio/src/utils/cell-renderer-monomer-placer';
+import {getUpdatedWidth, MonomerPlacer} from '@datagrok-libraries/bio/src/utils/cell-renderer-monomer-placer';
 import {
   getPaletteByType,
   monomerToShort,
@@ -20,31 +20,25 @@ import {
 } from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {SeqPalette} from '@datagrok-libraries/bio/src/seq-palettes';
 import {UnknownSeqPalettes} from '@datagrok-libraries/bio/src/unknown';
-import {GapOriginals, SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
-import {ISeqSplitted, SeqSplittedBase} from '@datagrok-libraries/bio/src/utils/macromolecule/types';
+import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {ISeqSplitted} from '@datagrok-libraries/bio/src/utils/macromolecule/types';
 import {getSplitter} from '@datagrok-libraries/bio/src/utils/macromolecule/utils';
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
-import {alphabetPolymerTypes, IMonomerLib} from '@datagrok-libraries/bio/src/types';
-import {getGridCellRendererBack} from '@datagrok-libraries/bio/src/utils/cell-renderer-back-base';
-
-import {
-  Temps as mmcrTemps,
-  tempTAGS, rendererSettingsChangedState, Temps
-} from '../utils/cell-renderer-consts';
+import {IMonomerLib} from '@datagrok-libraries/bio/src/types';
+import {GapOriginals} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
+import {ISeqMonomer} from '@datagrok-libraries/bio/src/helm/types';
+import {execMonomerHoverLinks} from '@datagrok-libraries/bio/src/monomer-works/monomer-hover';
+import {getGridCellColTemp} from '@datagrok-libraries/bio/src/utils/cell-renderer-back-base';
+import {HelmTypes} from '@datagrok-libraries/bio/src/helm/consts';
+import {MmcrTemps, rendererSettingsChangedState, tempTAGS} from '@datagrok-libraries/bio/src/utils/cell-renderer-consts';
 import * as C from './constants';
 
 import {_package, getMonomerLib} from '../package';
+import {max} from 'rxjs/operators';
 
 type TempType = { [tagName: string]: any };
 
-const undefinedColor = 'rgb(100,100,100)';
-const monomerToShortFunction: MonomerToShortFunc = monomerToShort;
-
-function getUpdatedWidth(
-  grid: DG.Grid | null | undefined, g: CanvasRenderingContext2D, x: number, w: number, dpr: number
-): number {
-  return !!grid ? Math.max(Math.min(grid.canvas.width / dpr - x, w)) : Math.max(g.canvas.width / dpr - x, 0);
-}
+export const monomerToShortFunction: MonomerToShortFunc = monomerToShort;
 
 export function processSequence(subParts: string[]): [string[], boolean] {
   const simplified = !wu.enumerate(subParts).some(([amino, index]) =>
@@ -65,12 +59,10 @@ export function processSequence(subParts: string[]): [string[], boolean] {
 }
 
 type RendererGridCellTemp = {
-  [mmcrTemps.monomerPlacer]: MonomerPlacer
+  [MmcrTemps.monomerPlacer]: MonomerPlacer
 }
 
 export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
-  private padding: number = 5;
-
   get name(): string { return 'sequence'; }
 
   get cellType(): string { return 'sequence'; }
@@ -85,13 +77,15 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
     gridCell.grid.invalidate();
   }
 
-  onMouseMove(gridCell: DG.GridCell, e: MouseEvent): void {
+  override onMouseMove(gridCell: DG.GridCell, e: MouseEvent): void {
+    if (gridCell.tableRowIndex == null) return;
+
     // if (gridCell.cell.column.getTag(bioTAGS.aligned) !== ALIGNMENT.SEQ_MSA)
     //   return;
 
     const [_gridCol, tableCol, temp] =
-      getGridCellRendererBack<string, MonomerPlacer>(gridCell);
-    const seqColTemp: MonomerPlacer = temp['rendererBack'];
+      getGridCellColTemp<string, MonomerPlacer>(gridCell);
+    const seqColTemp: MonomerPlacer = temp.rendererBack;
     if (!seqColTemp) return; // Can do nothing without precalculated data
 
     const gridCellBounds: DG.Rect = gridCell.bounds;
@@ -105,30 +99,39 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
     const argsX = e.offsetX - gridCell.gridColumn.left + (gridCell.gridColumn.left - gridCellBounds.x);
     const left: number | null = seqColTemp.getPosition(gridCell.tableRowIndex!, argsX, gridCellBounds.width);
 
-    const seqCList: SeqSplittedBase = SeqHandler.forColumn(tableCol)
-      .getSplitted(gridCell.tableRowIndex!).canonicals;
-    if (left !== null && left < seqCList.length) {
-      const monomerSymbol: string = seqCList[left];
+    const seqSS = SeqHandler.forColumn(tableCol)
+      .getSplitted(gridCell.tableRowIndex!);
+    if (left !== null && left < seqSS.length) {
+      const sh = SeqHandler.forColumn(tableCol);
+      const alphabet = sh.alphabet ?? ALPHABET.UN;
+      const seqMonomer = {
+        position: left,
+        biotype: alphabet === ALPHABET.RNA || alphabet === ALPHABET.DNA ? HelmTypes.NUCLEOTIDE : HelmTypes.AA,
+        symbol: seqSS.getCanonical(left),
+      } as ISeqMonomer;
       const tooltipElements: HTMLElement[] = [];
-      let monomerDiv = seqColTemp._monomerStructureMap[monomerSymbol];
+      let monomerDiv = seqColTemp._monomerStructureMap[seqMonomer.symbol];
       if (!monomerDiv || true) {
-        monomerDiv = seqColTemp._monomerStructureMap[monomerSymbol] = (() => {
-          const sh = SeqHandler.forColumn(tableCol);
-          const alphabet = sh.alphabet ?? ALPHABET.UN;
-          const polymerType = alphabetPolymerTypes[alphabet as ALPHABET];
-
+        monomerDiv = seqColTemp._monomerStructureMap[seqMonomer.symbol] = (() => {
           const lib: IMonomerLib | null = getMonomerLib();
-          return lib ? lib.getTooltip(polymerType, monomerSymbol) : ui.divText('Monomer library is not available');
+          return lib ? lib.getTooltip(seqMonomer.biotype, seqMonomer.symbol) : ui.divText('Monomer library is not available');
         })();
       }
       tooltipElements.push(monomerDiv);
       ui.tooltip.show(ui.divV(tooltipElements), e.x + 16, e.y + 16);
+
+      execMonomerHoverLinks(gridCell, seqMonomer);
     } else {
       //
       ui.tooltip.hide();
+      execMonomerHoverLinks(gridCell, null);
     }
   }
 
+  override onMouseLeave(gridCell: DG.GridCell, e: MouseEvent) {
+    execMonomerHoverLinks(gridCell, null);
+  }
+
   /**
    * Cell renderer function.
    *
@@ -147,9 +150,8 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
   ): void {
     const logPrefix: string = 'MacromoleculeSequenceCellRenderer.render()';
 
-    const dpr = window.devicePixelRatio;
     const [gridCol, tableCol, _temp] =
-      getGridCellRendererBack<string, MonomerPlacer>(gridCell);
+      getGridCellColTemp<string, MonomerPlacer>(gridCell);
     if (!tableCol) return;
     const tableColTemp: TempType = tableCol.temp;
 
@@ -162,13 +164,13 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
       const v = parseInt(tableCol.getTag(mmcrTAGS.maxMonomerLength));
       maxLengthOfMonomer = !isNaN(v) && v ? v : 50;
     }
-    if (Temps.maxMonomerLength in tableColTemp) {
-      const v = tableColTemp[Temps.maxMonomerLength];
+    if (MmcrTemps.maxMonomerLength in tableColTemp) {
+      const v = tableColTemp[MmcrTemps.maxMonomerLength];
       maxLengthOfMonomer = !isNaN(v) && v ? v : 50;
     }
 
     const [_gc, _tc, temp] =
-      getGridCellRendererBack<string, MonomerPlacer>(gridCell);
+      getGridCellColTemp<string, MonomerPlacer>(gridCell);
     let seqColTemp: MonomerPlacer = temp.rendererBack;
     if (!seqColTemp) {
       seqColTemp = temp.rendererBack = new MonomerPlacer(gridCol, tableCol, _package.logger, maxLengthOfMonomer,
@@ -182,91 +184,19 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
         });
     }
 
-    g.save();
-    try {
-      if (
-        tableCol.temp[Temps.rendererSettingsChanged] === rendererSettingsChangedState.true ||
-        seqColTemp.monomerLengthLimit != maxLengthOfMonomer
-      ) {
-        gapLength = tableColTemp[mmcrTemps.gapLength] as number ?? gapLength;
-        // this event means that the mm renderer settings have changed,
-        // particularly monomer representation and max width.
-        seqColTemp.setMonomerLengthLimit(maxLengthOfMonomer);
-        seqColTemp.setSeparatorWidth(seqColTemp.isMsa() ? msaGapLength : gapLength);
-        tableCol.temp[Temps.rendererSettingsChanged] = rendererSettingsChangedState.false;
-      }
-
-      const [maxLengthWords, maxLengthWordsSum]: [number[], number[]] =
-        seqColTemp.getCellMonomerLengths(gridCell.tableRowIndex!, w);
-      const _maxIndex = maxLengthWords.length;
-
-      const value: any = gridCell.cell.value;
-      const rowIdx = gridCell.cell.rowIndex;
-      const paletteType = tableCol.getTag(bioTAGS.alphabet);
-      const minDistanceRenderer = 50;
-      w = getUpdatedWidth(gridCol?.grid, g, x, w, dpr);
-      g.beginPath();
-      g.rect(x + this.padding, y + this.padding, w - this.padding - 1, h - this.padding * 2);
-      g.clip();
-      g.font = '12px monospace';
-      g.textBaseline = 'top';
-
-      //TODO: can this be replaced/merged with splitSequence?
-      const units = tableCol.meta.units;
-      const aligned: string = tableCol.getTag(bioTAGS.aligned);
-
-      const palette = getPaletteByType(paletteType);
-
-      const separator = tableCol.getTag(bioTAGS.separator) ?? '';
-      const minMonWidth = seqColTemp.props.separatorWidth + 1 * seqColTemp.props.monomerCharWidth;
-      const splitLimit = Math.ceil(w / minMonWidth);
-      const sh = SeqHandler.forColumn(tableCol);
-
-      const tempReferenceSequence: string | null = tableColTemp[tempTAGS.referenceSequence];
-      const tempCurrentWord: string | null = tableColTemp[tempTAGS.currentWord];
-      if (tempCurrentWord && tableCol?.dataFrame?.currentRowIdx === -1)
-        tableColTemp[tempTAGS.currentWord] = null;
-
-      const referenceSequence: string[] = (() => {
-        // @ts-ignore
-        const splitterFunc: SplitterFunc = sh.getSplitter(splitLimit);
-        return wu(splitterFunc(
-          ((tempReferenceSequence != null) && (tempReferenceSequence != '')) ?
-            tempReferenceSequence : tempCurrentWord ?? '').originals).toArray();
-      })();
-
-      const subParts: ISeqSplitted = sh.getSplitted(rowIdx);
-      /* let x1 = x; */
-      let color = undefinedColor;
-      let drawStyle = DrawStyle.classic;
-
-      if (aligned && aligned.includes('MSA') && units == NOTATION.SEPARATOR)
-        drawStyle = DrawStyle.MSA;
-
-      const visibleSeqLength = Math.min(subParts.length, splitLimit);
-      for (let posIdx: number = 0; posIdx < visibleSeqLength; ++posIdx) {
-        const amino: string = subParts.getOriginal(posIdx);
-        color = palette.get(amino);
-        g.fillStyle = undefinedColor;
-        const last = posIdx === subParts.length - 1;
-        /*x1 = */
-        const opts = {
-          color: color, pivot: 0, left: true, transparencyRate: 1.0, separator: separator, last: last,
-          drawStyle: drawStyle, maxWord: maxLengthWordsSum, wordIdx: posIdx, gridCell: gridCell,
-          referenceSequence: referenceSequence, maxLengthOfMonomer: maxLengthOfMonomer,
-          monomerTextSizeMap: seqColTemp._monomerLengthMap, logger: _package.logger
-        };
-        printLeftOrCentered(g, amino, x + this.padding, y, w, h, opts);
-        if (minDistanceRenderer > w) break;
-      }
-    } catch (err: any) {
-      const [errMsg, errStack] = errInfo(err);
-      seqColTemp.logger.error(errMsg, undefined, errStack);
-      seqColTemp.errors.push(err);
-      //throw err; // Do not throw to prevent disabling renderer
-    } finally {
-      g.restore();
+    if (
+      tableCol.temp[MmcrTemps.rendererSettingsChanged] === rendererSettingsChangedState.true ||
+      seqColTemp.monomerLengthLimit != maxLengthOfMonomer
+    ) {
+      gapLength = tableColTemp[MmcrTemps.gapLength] as number ?? gapLength;
+      // this event means that the mm renderer settings have changed,
+      // particularly monomer representation and max width.
+      seqColTemp.setMonomerLengthLimit(maxLengthOfMonomer);
+      seqColTemp.setSeparatorWidth(seqColTemp.isMsa() ? msaGapLength : gapLength);
+      tableCol.temp[MmcrTemps.rendererSettingsChanged] = rendererSettingsChangedState.false;
     }
+
+    seqColTemp.render(g, x, y, w, h, gridCell, _cellStyle);
   }
 }
 
@@ -306,8 +236,10 @@ export class MacromoleculeDifferenceCellRenderer extends DG.GridCellRenderer {
     //TODO: can this be replaced/merged with splitSequence?
     const [s1, s2] = s.split('#');
     const splitter = getSplitter(units, separator);
-    const subParts1 = wu(splitter(s1).canonicals).toArray();
-    const subParts2 = wu(splitter(s2).canonicals).toArray();
+    const s1SS = splitter(s1);
+    const s2SS = splitter(s2);
+    const subParts1 = wu.count(0).take(s1SS.length).map((posIdx) => s1SS.getCanonical(posIdx)).toArray();
+    const subParts2 = wu.count(0).take(s2SS.length).map((posIdx) => s2SS.getCanonical(posIdx)).toArray();
     drawMoleculeDifferenceOnCanvas(g, x, y, w, h, subParts1, subParts2, units);
   }
 }

package/src/utils/cyclized.ts

@@ -2,11 +2,20 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {GAP_SYMBOL, INotationProvider, ISeqSplitted, SeqSplittedBase, SplitterFunc}
+import wu from 'wu';
+
+import {INotationProvider, ISeqSplitted, SeqSplittedBase, SplitterFunc}
   from '@datagrok-libraries/bio/src/utils/macromolecule/types';
 import {getSplitterWithSeparator, StringListSeqSplitted} from '@datagrok-libraries/bio/src/utils/macromolecule/utils';
-import {GapOriginals} from '@datagrok-libraries/bio/src/utils/seq-handler';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {CellRendererBackBase} from '@datagrok-libraries/bio/src/utils/cell-renderer-back-base';
+import {GAP_SYMBOL, GapOriginals} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
+import {MonomerPlacer} from '@datagrok-libraries/bio/src/utils/cell-renderer-monomer-placer';
+import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+
+import {monomerToShortFunction} from './cell-renderer';
+
+import {_package} from '../package';
 
 export class CyclizedNotationProvider implements INotationProvider {
   private readonly separatorSplitter: SplitterFunc;
@@ -21,7 +30,9 @@ export class CyclizedNotationProvider implements INotationProvider {
 
   private _splitter(seq: string): ISeqSplitted {
     const baseSS: ISeqSplitted = this.separatorSplitter(seq);
-    return new CyclizedSeqSplitted(baseSS.originals, GapOriginals[NOTATION.SEPARATOR]);
+    return new CyclizedSeqSplitted(
+      wu.count(0).take(baseSS.length).map((p) => baseSS.getOriginal(p)).toArray(),
+      GapOriginals[NOTATION.SEPARATOR]);
   }
 
   public async getHelm(seqCol: DG.Column<string>, options?: any): Promise<DG.Column<string>> {
@@ -38,23 +49,26 @@ export class CyclizedNotationProvider implements INotationProvider {
     const resHelmCol = (await editorFunc.prepare({call: ptConvertCall}).call()).getOutputParamValue() as DG.Column<string>;
     return resHelmCol;
   }
+
+  public createCellRendererBack(gridCol: DG.GridColumn | null, tableCol: DG.Column<string>): CellRendererBackBase<string> {
+    let maxLengthOfMonomer: number = (_package.properties ? _package.properties.maxMonomerLength : 4) ?? 50;
+    return new MonomerPlacer(gridCol, tableCol, _package.logger, maxLengthOfMonomer,
+      () => {
+        const sh = SeqHandler.forColumn(tableCol);
+        return {
+          seqHandler: sh,
+          monomerCharWidth: 7,
+          separatorWidth: 11,
+          monomerToShort: monomerToShortFunction,
+        };
+      });
+  }
 }
 
 /** Gets canonical monomers for original ones with cyclization marks */
 export class CyclizedSeqSplitted extends StringListSeqSplitted {
   private readonly seqCList: (string | null)[];
 
-  private _canonicals: string[] | null = null;
-  override get canonicals(): SeqSplittedBase {
-    if (!this._canonicals) {
-      const len = this.length;
-      this._canonicals = new Array<string>(len);
-      for (let posIdx = 0; posIdx < len; ++posIdx)
-        this._canonicals[posIdx] = this.getCanonical(posIdx);
-    }
-    return this._canonicals;
-  }
-
   override getCanonical(posIdx: number): string {
     if (this.isGap(posIdx)) return GAP_SYMBOL;
 

package/src/utils/dimerized.ts

@@ -2,8 +2,6 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {GAP_SYMBOL, INotationProvider, ISeqSplitted, SeqSplittedBase, SplitterFunc}
-  from '@datagrok-libraries/bio/src/utils/macromolecule/types';
 import {CyclizedNotationProvider} from './cyclized';
 
 

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

@@ -4,37 +4,39 @@ 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 {IMonomerLib} from '@datagrok-libraries/bio/src/types/index';
+import {IMonomerLib, IMonomerLibBase} from '@datagrok-libraries/bio/src/types/index';
 import {IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
+import {MolfileWithMap, MonomerMap} from '@datagrok-libraries/bio/src/monomer-works/types';
 
 import {Polymer} from './polymer';
 import {GlobalMonomerPositionHandler} from './position-handler';
-import {MolfileWithMap, MonomerMap} from './types';
 
 import {_package} from '../../../package';
+import {getUnusedColName} from '@datagrok-libraries/bio/src/monomer-works/utils';
 
 
 export class HelmToMolfileConverter {
   constructor(
-    private helmColumn: DG.Column<string>,
-    private df: DG.DataFrame,
-    private libHelper: IMonomerLibHelper,
-    private helmHelper: IHelmHelper,
+    private readonly helmHelper: IHelmHelper,
+    private readonly rdKitModule: RDModule,
+    private readonly monomerLib: IMonomerLibBase
   ) { }
 
-  convertToSmiles(rdKitModule: RDModule): DG.Column<string> {
-    const smiles = this.getSmilesList(rdKitModule);
-    const columnName = this.df.columns.getUnusedName(`smiles(${this.helmColumn.name})`);
-    return DG.Column.fromStrings(columnName, smiles.map((molecule) => {
+  convertToSmiles(helmCol: DG.Column<string>): DG.Column<string> {
+    const df = helmCol.dataFrame;
+    const smiles = this.getSmilesList(helmCol);
+    const smilesColName = `smiles(${helmCol.name})`;
+    const smilesColNameU = df ? df.columns.getUnusedName(smilesColName) : smilesColName;
+    return DG.Column.fromStrings(smilesColNameU, smiles.map((molecule) => {
       if (molecule === null)
         return '';
       return molecule;
     }));
   }
 
-  private getSmilesList(rdKitModule: RDModule): string[] {
-    const molfilesV2K = this.convertToMolfileV3KColumn(rdKitModule).toList();
+  private getSmilesList(helmCol: DG.Column<string>): string[] {
+    const molfilesV2K = this.convertToMolfileV3KColumn(helmCol).toList();
     const smiles = molfilesV2K.map((mol) => DG.chem.convert(mol, DG.chem.Notation.MolBlock, DG.chem.Notation.Smiles));
     return smiles;
   }
@@ -61,8 +63,11 @@ export class HelmToMolfileConverter {
   }
 
   // @deprecated Use SeqHelper.helmToAtomicLevel
-  convertToRdKitBeautifiedMolfileColumn(chiralityEngine: boolean, rdKitModule: RDModule): DG.Column<string> {
-    const molfilesV3K = this.convertToMolfileV3KColumn(rdKitModule).toList();
+  convertToRdKitBeautifiedMolfileColumn(
+    helmCol: DG.Column<string>, chiralityEngine: boolean, rdKitModule: RDModule, monomerLib: IMonomerLibBase
+  ): DG.Column<string> {
+    const df = helmCol.dataFrame;
+    const molfilesV3K = this.convertToMolfileV3KColumn(helmCol).toList();
     const beautifiedMols = molfilesV3K.map((item) => {
       if (item === '')
         return null;
@@ -74,11 +79,12 @@ export class HelmToMolfileConverter {
       mol.straighten_depiction(true);
       return mol;
     });
-    const columnName = this.df.columns.getUnusedName(`molfile(${this.helmColumn.name})`);
+    const molColName = `molfile(${helmCol.name})`;
+    const molColNameU = df ? df.columns.getUnusedName(molColName) : molColName;
 
     if (chiralityEngine)
-      return this.getMolV3000ViaOCL(beautifiedMols, columnName);
-    return DG.Column.fromStrings(columnName, beautifiedMols.map((mol) => {
+      return this.getMolV3000ViaOCL(beautifiedMols, molColNameU);
+    return DG.Column.fromStrings(molColNameU, beautifiedMols.map((mol) => {
       if (mol === null)
         return '';
       const molBlock = mol.get_v3Kmolblock();
@@ -88,71 +94,86 @@ export class HelmToMolfileConverter {
   }
 
 
-  public convertToMolfileV3KColumn(rdKitModule: RDModule): DG.Column<string> {
-    const polymerGraphColumn: DG.Column<string> = this.getPolymerGraphColumn();
-    const monomerLib: IMonomerLib = this.libHelper.getMonomerLib();
+  public convertToMolfileV3KColumn(
+    helmCol: DG.Column<string>
+  ): DG.Column<string> {
+    const df = helmCol.dataFrame;
+    const polymerGraphColumn: DG.Column<string> = this.getPolymerGraphColumn(helmCol);
     const molfileList = polymerGraphColumn.toList().map(
       (pseudoMolfile: string, idx: number) => {
-        const helm = this.helmColumn.get(idx);
+        const helm = helmCol.get(idx);
         if (!helm) return '';
 
         let resMolfileWithMap: MolfileWithMap;
         try {
-          resMolfileWithMap = this.getPolymerMolfile(helm, pseudoMolfile, rdKitModule, monomerLib);
+          resMolfileWithMap = this.getPolymerMolfile(helm, pseudoMolfile);
         } catch (err: any) {
           const [errMsg, errStack] = errInfo(err);
           _package.logger.error(errMsg, undefined, errStack);
-          resMolfileWithMap = MolfileWithMap.empty();
+          resMolfileWithMap = MolfileWithMap.createEmpty();
         }
         return resMolfileWithMap.molfile;
       });
-    const molfileColName = this.df.columns.getUnusedName(`molfileV2K(${this.helmColumn.name})`);
-    const molfileColumn = DG.Column.fromList('string', molfileColName, molfileList);
+    const molColName = getUnusedColName(df, `molfileV2K(${helmCol.name})`);
+    const molfileColumn = DG.Column.fromList('string', molColName, molfileList);
     return molfileColumn;
   }
 
-  public convertToMolfileV3K(rdKitModule: RDModule): MolfileWithMap[] {
-    const polymerGraphColumn: DG.Column<string> = this.getPolymerGraphColumn();
-    const monomerLib: IMonomerLib = this.libHelper.getMonomerLib();
-    const resList: MolfileWithMap[] = polymerGraphColumn.toList().map(
-      (pseudoMolfile: string, idx: number): MolfileWithMap => {
-        const helm = this.helmColumn.get(idx);
-        if (!helm) return {molfile: '', monomers: []};
-
-        let resMolfile: MolfileWithMap;
-        try {
-          resMolfile = this.getPolymerMolfile(helm, pseudoMolfile, rdKitModule, monomerLib);
-        } catch (err: any) {
-          const [errMsg, errStack] = errInfo(err);
-          _package.logger.error(errMsg, undefined, errStack);
-          resMolfile = MolfileWithMap.empty();
-        }
-        return resMolfile;
-      });
+  /** Gets list of monomer molfiles */
+  public convertToMolfileV3K(helmCol: DG.Column<string>, rdKitModule: RDModule, monomerLib: IMonomerLibBase): MolfileWithMap[] {
+    const polymerGraphColumn: DG.Column<string> = this.getPolymerGraphColumn(helmCol);
+    const rowCount = helmCol.length;
+    const resList: MolfileWithMap[] = new Array<MolfileWithMap>(rowCount);
+    for (let rowIdx = 0; rowIdx < rowCount; ++rowIdx) {
+      const helm = helmCol.get(rowIdx);
+      if (!helm) {
+        resList[rowIdx] = MolfileWithMap.createEmpty();
+        continue;
+      }
+
+      const pseudoMolfile = polymerGraphColumn.get(rowIdx)!;
+      let resMolfile: MolfileWithMap;
+      try {
+        resMolfile = this.getPolymerMolfile(helm, pseudoMolfile);
+      } catch (err: any) {
+        const [errMsg, errStack] = errInfo(err);
+        _package.logger.error(errMsg, undefined, errStack);
+        resMolfile = MolfileWithMap.createEmpty();
+      }
+      resList[rowIdx] = resMolfile;
+    }
     return resList;
   }
 
-  private getPolymerGraphColumn(): DG.Column<string> {
-    const helmStrList = this.helmColumn.toList();
+  private getPolymerGraphColumn(helmCol: DG.Column<string>): DG.Column<string> {
+    const helmStrList = helmCol.toList();
     const molfileList = this.helmHelper.getMolfiles(helmStrList);
     const molfileCol = DG.Column.fromStrings('mols', molfileList);
     return molfileCol;
   }
 
   private getPolymerMolfile(
-    helm: string,
-    polymerGraph: string,
-    rdKitModule: RDModule,
-    monomerLib: IMonomerLib
+    helm: string, polymerGraph: string
   ): MolfileWithMap {
+    const woGapsRes = this.helmHelper.removeGaps(helm);
+    const woGapsHelm = woGapsRes.resHelm;
+    const woGapsReverseMap = new Map<number, number>();
+    for (const [orgPosIdx, woGapsPosIdx] of (woGapsRes.monomerMap?.entries() ?? [])) {
+      woGapsReverseMap.set(woGapsPosIdx, orgPosIdx);
+    }
     const globalPositionHandler = new GlobalMonomerPositionHandler(polymerGraph);
-    const polymer = new Polymer(helm, rdKitModule, monomerLib);
+    const woGapsPolymer = new Polymer(woGapsHelm, this.rdKitModule, this.monomerLib);
     globalPositionHandler.monomerSymbols.forEach((monomerSymbol: string, monomerIdx: number) => {
       const shift = globalPositionHandler.getMonomerShifts(monomerIdx);
-      polymer.addMonomer(monomerSymbol, monomerIdx, shift);
+      woGapsPolymer.addMonomer(monomerSymbol, monomerIdx, shift);
     });
-    const polymerMolfile: MolfileWithMap = polymer.compileToMolfile();
-    return polymerMolfile;
+    const woGapsMolfile: MolfileWithMap = woGapsPolymer.compileToMolfile();
+    const orgMonomerMap = new MonomerMap();
+    for (const [woGapsPosIdx, m] of woGapsMolfile.monomers.entries()) {
+      const orgPosIdx = woGapsReverseMap.get(woGapsPosIdx)!;
+      orgMonomerMap.set(orgPosIdx, m);
+    }
+
+    return new MolfileWithMap(woGapsMolfile.molfile, orgMonomerMap);
   }
 }
-