@datagrok/bio 2.15.13 → 2.16.0

package/src/utils/seq-helper/seq-helper.ts

@@ -15,9 +15,8 @@ import {getMolHighlight} from '@datagrok-libraries/bio/src/monomer-works/seq-to-
 import {IMonomerLibBase} from '@datagrok-libraries/bio/src/types/index';
 
 import {HelmToMolfileConverter} from '../helm-to-molfile/converter';
-import {MonomerLibManager} from '../monomer-lib/lib-manager';
-
-import {_package, getMonomerLibHelper} from '../../package';
+import {ISeqHandler} from '@datagrok-libraries/bio/src/utils/macromolecule/seq-handler';
+import {SeqHandler} from './seq-handler';
 
 type SeqHelperWindowType = Window & { $seqHelperPromise?: Promise<SeqHelper> };
 declare const window: SeqHelperWindowType;
@@ -25,12 +24,17 @@ declare const window: SeqHelperWindowType;
 export class SeqHelper implements ISeqHelper {
   constructor(
     private readonly libHelper: IMonomerLibHelper,
-    private readonly helmHelper: IHelmHelper,
     private readonly rdKitModule: RDModule
   ) {}
 
-  getHelmToMolfileConverter(monomerLib: IMonomerLibBase): HelmToMolfileConverter {
-    return new HelmToMolfileConverter(this.helmHelper, this.rdKitModule, monomerLib);
+  getSeqHandler(seqCol: DG.Column<string>): ISeqHandler {
+    return SeqHandler.forColumn(seqCol);
+  }
+
+  // TODO: Move to the Helm package
+  async getHelmToMolfileConverter(monomerLib: IMonomerLibBase): Promise<HelmToMolfileConverter> {
+    const helmHelper: IHelmHelper = await getHelmHelper();
+    return new HelmToMolfileConverter(helmHelper, this.rdKitModule, monomerLib);
   }
 
   async helmToAtomicLevel(
@@ -41,7 +45,7 @@ export class SeqHelper implements ISeqHelper {
     const df: DG.DataFrame = helmCol.dataFrame;
     const molColName: string = getMolColName(df, helmCol.name);
 
-    const converter = this.getHelmToMolfileConverter(monomerLib);
+    const converter = await this.getHelmToMolfileConverter(monomerLib);
 
     //#region From HelmToMolfileConverter.convertToRdKitBeautifiedMolfileColumn
 
@@ -85,18 +89,4 @@ export class SeqHelper implements ISeqHelper {
 
     return {molCol: molCol, warnings: []};
   }
-
-  static getInstance(): Promise<SeqHelper> {
-    let res = window.$seqHelperPromise;
-    if (res == undefined) {
-      res = window.$seqHelperPromise = (async () => {
-        if (!_package.initialized)
-          throw new Error('Bio package is not initialized, call Bio:getSeqHelper');
-        const instance = new SeqHelper(
-          await MonomerLibManager.getInstance(), await getHelmHelper(), _package.rdKitModule);
-        return instance;
-      })();
-    }
-    return res;
-  }
 }

package/src/utils/sequence-to-mol.ts

@@ -4,24 +4,23 @@ import * as DG from 'datagrok-api/dg';
 
 import {_toAtomicLevel} from '@datagrok-libraries/bio/src/monomer-works/to-atomic-level';
 import {IMonomerLib} from '@datagrok-libraries/bio/src/types';
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {getSeqHelper, ToAtomicLevelRes} from '@datagrok-libraries/bio/src/utils/seq-helper';
+import {getSeqHelper, ISeqHelper, ToAtomicLevelRes} from '@datagrok-libraries/bio/src/utils/seq-helper';
 import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
 import {ChemTags, ChemTemps} from '@datagrok-libraries/chem-meta/src/consts';
 import {buildMonomerHoverLink} from '@datagrok-libraries/bio/src/monomer-works/monomer-hover';
 
-import {checkInputColumnUI} from './check-input-column';
+import {checkInputColumn, checkInputColumnUI} from './check-input-column';
 import {getMolColName} from '@datagrok-libraries/bio/src/monomer-works/utils';
 
 export async function sequenceToMolfile(
   df: DG.DataFrame, macroMolecule: DG.Column, nonlinear: boolean, highlight: boolean,
-  monomerLib: IMonomerLib, rdKitModule: RDModule
+  monomerLib: IMonomerLib, seqHelper: ISeqHelper, rdKitModule: RDModule
 ): Promise<ToAtomicLevelRes> {
   let res: ToAtomicLevelRes;
   if (nonlinear) {
     const seqHelper = await getSeqHelper();
-    const seqSh = SeqHandler.forColumn(macroMolecule);
+    const seqSh = seqHelper.getSeqHandler(macroMolecule);
 
     let helmCol: DG.Column<string>;
     let seqColName!: string;
@@ -43,10 +42,10 @@ export async function sequenceToMolfile(
       }
     }
   } else { // linear
-    if (!checkInputColumnUI(macroMolecule, 'To Atomic Level'))
+    if (!checkInputColumn(macroMolecule, 'To Atomic Level', seqHelper)[0])
       return {molCol: null, warnings: ['Column is not suitable']};
 
-    res = await _toAtomicLevel(df, macroMolecule, monomerLib, rdKitModule);
+    res = await _toAtomicLevel(df, macroMolecule, monomerLib, seqHelper, rdKitModule);
   }
 
   if (res.molCol) {
@@ -54,7 +53,7 @@ export async function sequenceToMolfile(
     res.molCol.name = molColName;
     df.columns.add(res.molCol, true);
 
-    buildMonomerHoverLink(macroMolecule, res.molCol, monomerLib, rdKitModule);
+    buildMonomerHoverLink(macroMolecule, res.molCol, monomerLib, seqHelper, rdKitModule);
     res.molCol.setTag(ChemTags.SEQUENCE_SRC_HL_MONOMERS, String(highlight));
     await grok.data.detectSemanticTypes(df);
   }

package/src/utils/split-to-monomers.ts

@@ -8,15 +8,20 @@ import {splitAlignedSequences} from '@datagrok-libraries/bio/src/utils/splitter'
 import * as C from './constants';
 import {TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
 import {SEM_TYPES} from './constants';
+import {ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
+import {_package} from '../package';
 
 
-export async function splitToMonomersUI(table: DG.DataFrame, seqCol: DG.Column<string>): Promise<DG.DataFrame> {
+export async function splitToMonomersUI(
+  table: DG.DataFrame, seqCol: DG.Column<string>
+): Promise<DG.DataFrame> {
   // Delay is required for initial function dialog to close before starting invalidating of molfiles.
   // Otherwise, dialog is freezing
   await delay(10);
   if (!checkInputColumnUI(seqCol, 'Sequence space')) return table;
 
-  const tempDf = splitAlignedSequences(seqCol);
+  const seqHelper = _package.seqHelper;
+  const tempDf = splitAlignedSequences(seqCol, seqHelper);
   tempDf.name = 'splitToMonomers';
   const originalDf = seqCol.dataFrame;
   for (const tempCol of tempDf.columns) {

package/src/utils/types.ts

@@ -1,19 +1,20 @@
 import * as DG from 'datagrok-api/dg';
 import {pepseaMethods} from './pepsea';
-export type DataFrameDict = {[key: string]: DG.DataFrame};
+
+export type DataFrameDict = { [key: string]: DG.DataFrame };
 
 export namespace BarChart {
-  export type BarPart = {colName : string, aaName : string};
-  export type BarStatsObject = {name: string, count: number, selectedCount: number};
+  export type BarPart = { colName: string, aaName: string };
+  export type BarStatsObject = { name: string, count: number, selectedCount: number };
 }
 
 export type UTypedArray = Uint8Array | Uint16Array | Uint32Array;
 //AAR: (Position: (index: indexList))
 export type SubstitutionsInfo = Map<string, Map<string, Map<number, number[] | UTypedArray>>>;
-export type SelectionObject = {[postiton: string]: string[]};
+export type SelectionObject = { [position: string]: string[] };
 
-export type multipleSequenceAlginmentUIOptions = {
+export type MultipleSequenceAlignmentUIOptions = {
   col?: DG.Column<string> | null, clustersCol?: DG.Column | null,
-  pepsea?: {method?: typeof pepseaMethods[number], gapOpen?: number, gapExtend?: number},
-  kalign?: {gapOpen?: number, gapExtend?: number, terminalGap?: number}
+  pepsea?: { method?: typeof pepseaMethods[number], gapOpen?: number, gapExtend?: number },
+  kalign?: { gapOpen?: number, gapExtend?: number, terminalGap?: number }
 };

package/src/utils/ui-utils.ts

@@ -1,11 +1,11 @@
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 
-export function getMacromoleculeColumns(): DG.Column<any>[] | any {
+export function getMacromoleculeColumns(): DG.Column<string>[] {
   const columns = grok.shell.t.columns.bySemTypeAll(DG.SEMTYPE.MACROMOLECULE);
   if (columns === null) {
     grok.shell.error('Current table does not contain macromolecules');
-    return;
+    return [];
   }
   return columns;
 }

package/src/viewers/web-logo-viewer.ts

@@ -6,7 +6,8 @@ import $ from 'cash-dom';
 import wu from 'wu';
 import {fromEvent, Observable, Subject, Unsubscribable} from 'rxjs';
 
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
+import {ISeqHandler} from '@datagrok-libraries/bio/src/utils/macromolecule/seq-handler';
 import {
   monomerToShort, pickUpSeqCol, TAGS as bioTAGS, positionSeparator, ALPHABET
 } from '@datagrok-libraries/bio/src/utils/macromolecule';
@@ -308,7 +309,8 @@ export class WebLogoViewer extends DG.JsViewer implements IWebLogoViewer {
 
   private viewed: boolean = false;
 
-  private seqHandler: SeqHandler | null;
+  private seqHelper: ISeqHelper;
+  private seqHandler: ISeqHandler | null;
   private initialized: boolean = false;
 
   private monomerLib: IMonomerLibBase | null = null;
@@ -387,6 +389,7 @@ export class WebLogoViewer extends DG.JsViewer implements IWebLogoViewer {
   constructor() {
     super();
 
+    this.seqHelper = _package.seqHelper;
     this.textBaseline = 'top';
     this.seqHandler = null;
 
@@ -606,7 +609,7 @@ export class WebLogoViewer extends DG.JsViewer implements IWebLogoViewer {
       }
       if (this.seqCol) {
         try {
-          this.seqHandler = SeqHandler.forColumn(this.seqCol);
+          this.seqHandler = this.seqHelper.getSeqHandler(this.seqCol);
 
           this.render(WlRenderLevel.Freqs, 'updateSeqCol()');
           this.error = null;
@@ -1006,7 +1009,7 @@ export class WebLogoViewer extends DG.JsViewer implements IWebLogoViewer {
       // endregion updatePositions
 
       const length: number = this.startPosition <= this.endPosition ? this.endPosition - this.startPosition + 1 : 0;
-      this.seqHandler = SeqHandler.forColumn(this.seqCol);
+      this.seqHandler = this.seqHelper.getSeqHandler(this.seqCol);
       const posCount: number = this.startPosition <= this.endPosition ? this.endPosition - this.startPosition + 1 : 0;
       this.positions = new Array(posCount);
       for (let jPos = 0; jPos < length; jPos++) {
@@ -1073,7 +1076,7 @@ export class WebLogoViewer extends DG.JsViewer implements IWebLogoViewer {
       const absoluteMaxHeight: number = this.canvas.height - positionLabelsHeight * dpr;
       let alphabetSizeLog: number;
       if (this.valueAggrType === DG.AGG.TOTAL_COUNT) {
-        const alphabetSize: number = this.getAlphabetSize();
+        const alphabetSize: number = this.seqHandler!.getAlphabetSize();
         if ((this.positionHeight == PositionHeight.Entropy) && (alphabetSize == null))
           grok.shell.error('WebLogo: alphabet is undefined.');
         alphabetSizeLog = Math.log2(alphabetSize);
@@ -1139,8 +1142,7 @@ export class WebLogoViewer extends DG.JsViewer implements IWebLogoViewer {
       // Hacks to scale uppercase characters to target rectangle
       const uppercaseLetterAscent = 0.25;
       const uppercaseLetterHeight = 12.2;
-      const sh = SeqHandler.forColumn(this.seqCol);
-      const biotype = sh.defaultBiotype;
+      const biotype = this.seqHandler!.defaultBiotype;
       for (let jPos = firstPos; jPos <= lastPos; jPos++)
         this.positions[jPos].render(g, fontStyle, uppercaseLetterAscent, uppercaseLetterHeight, biotype, this.monomerLib);
     } finally {
@@ -1165,9 +1167,9 @@ export class WebLogoViewer extends DG.JsViewer implements IWebLogoViewer {
   private _lastWidth: number;
   private _lastHeight: number;
 
-  public getAlphabetSize(): number {
-    return this.seqHandler?.getAlphabetSize() ?? 0;
-  }
+  // public getAlphabetSize(): number {
+  //   return this.seqHandler?.getAlphabetSize() ?? 0;
+  // }
 
   // -- Handle events --
 
@@ -1215,7 +1217,8 @@ export class WebLogoViewer extends DG.JsViewer implements IWebLogoViewer {
     }
   }
 
-  private canvasOnMouseMove(e: MouseEvent) {
+  private canvasOnMouseMove(e: MouseEvent): void {
+    if (!this.monomerLib || !this.seqHandler) return;
     const dpr = window.devicePixelRatio;
     try {
       const args = e as MouseEvent;
@@ -1224,13 +1227,12 @@ export class WebLogoViewer extends DG.JsViewer implements IWebLogoViewer {
       const [pi, monomer] = this.getMonomer(cursorP, dpr);
       const positionLabelHeight = this.showPositionLabels ? POSITION_LABELS_HEIGHT * dpr : 0;
 
-      if (pi !== null && monomer === null && 0 <= cursorP.y && cursorP.y <= positionLabelHeight && this.monomerLib) {
+      if (pi !== null && monomer === null && 0 <= cursorP.y && cursorP.y <= positionLabelHeight) {
         // Position tooltip
 
         const tooltipRows = [ui.divText(`Position ${pi.label}`)];
         if (this.valueAggrType === DG.AGG.TOTAL_COUNT) {
-          const sh = SeqHandler.forColumn(this.seqCol!);
-          const biotype = sh.defaultBiotype;
+          const biotype = this.seqHandler!.defaultBiotype;
           tooltipRows.push(pi.buildCompositionTable(biotype, this.monomerLib));
         }
         const tooltipEl = ui.divV(tooltipRows);
@@ -1356,7 +1358,7 @@ function renderPositionLabels(g: CanvasRenderingContext2D,
 }
 
 export function checkSeqForMonomerAtPos(
-  df: DG.DataFrame, sh: SeqHandler, filter: DG.BitSet, rowI: number, monomer: string, at: PositionInfo,
+  df: DG.DataFrame, sh: ISeqHandler, filter: DG.BitSet, rowI: number, monomer: string, at: PositionInfo,
 ): boolean {
   const seqMList: ISeqSplitted = sh.getSplitted(rowI);
   const seqCM: string | null = at.pos < seqMList.length ? seqMList.getCanonical(at.pos) : null;
@@ -1364,7 +1366,7 @@ export function checkSeqForMonomerAtPos(
 }
 
 export function countForMonomerAtPosition(
-  df: DG.DataFrame, sh: SeqHandler, filter: DG.BitSet, monomer: string, at: PositionInfo
+  df: DG.DataFrame, sh: ISeqHandler, filter: DG.BitSet, monomer: string, at: PositionInfo
 ): number {
   let count = 0;
   let rowI = -1;

package/src/widgets/bio-substructure-filter.ts

@@ -16,7 +16,6 @@ import {TAGS as bioTAGS, NOTATION} from '@datagrok-libraries/bio/src/utils/macro
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
 import {delay, testEvent} from '@datagrok-libraries/utils/src/test';
 import {getHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 import {IRenderer} from '@datagrok-libraries/bio/src/types/renderer';
 import {ILogger} from '@datagrok-libraries/bio/src/utils/logger';
 import {PromiseSyncer} from '@datagrok-libraries/bio/src/utils/syncer';
@@ -125,7 +124,7 @@ export class BioSubstructureFilter extends DG.Filter implements IRenderer {
         else
           this.column = dataFrame.columns.bySemType(DG.SEMTYPE.MACROMOLECULE);
       }
-      const sh = SeqHandler.forColumn(this.column!);
+      const sh = _package.seqHelper.getSeqHandler(this.column!);
       this.columnName ??= this.column?.name;
       this.notation ??= this.column?.meta.units!;
 

package/src/widgets/composition-analysis-widget.ts

@@ -4,25 +4,25 @@ import * as DG from 'datagrok-api/dg';
 
 import wu from 'wu';
 
-import {TAGS as bioTAGS, ALPHABET, getPaletteByType} 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 {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {TAGS as bioTAGS, ALPHABET} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {GAP_SYMBOL} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
 import {IMonomerLibBase} from '@datagrok-libraries/bio/src/types';
 import {HelmType} from '@datagrok-libraries/bio/src/helm/types';
 import {HelmTypes} from '@datagrok-libraries/bio/src/helm/consts';
 
 import '../../css/composition-analysis.css';
+import {ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 
-export function getCompositionAnalysisWidget(val: DG.SemanticValue, monomerLib: IMonomerLibBase): DG.Widget {
+export function getCompositionAnalysisWidget(
+  val: DG.SemanticValue, monomerLib: IMonomerLibBase, seqHelper: ISeqHelper
+): DG.Widget {
   const host = ui.div();
   host.classList.add('macromolecule-cell-comp-analysis-host');
   const alphabet = val.cell.column.tags[bioTAGS.alphabet];
   const biotype = alphabet === ALPHABET.DNA || alphabet === ALPHABET.RNA ? HelmTypes.NUCLEOTIDE : HelmTypes.AA;
 
   const counts: { [m: string]: number } = {};
-  const sh = SeqHandler.forColumn(val.cell.column as DG.Column<string>);
+  const sh = seqHelper.getSeqHandler(val.cell.column as DG.Column<string>);
   const rowIdx = val.cell.rowIndex;
   const seqSS = sh.getSplitted(rowIdx);
   wu.count(0).take(seqSS.length).filter((posIdx) => !seqSS.isGap(posIdx)).forEach((posIdx) => {

package/src/widgets/representations.ts

@@ -2,13 +2,13 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {getMolfilesFromSingleSeq} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {TAGS as mmcrTAGS} from '@datagrok-libraries/bio/src/utils/cell-renderer';
 
 import {MmcrTemps, rendererSettingsChangedState} from '@datagrok-libraries/bio/src/utils/cell-renderer-consts';
+import {ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
+import {getMolfilesFromSingleSeq} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 
 import {_package} from '../package';
-import {max} from 'rxjs/operators';
 
 
 /**
@@ -105,16 +105,19 @@ export function getMacromoleculeColumnPropertyPanel(col: DG.Column): DG.Widget {
  * @export
  * @param {DG.Cell} macroMolecule macromolecule cell.
  * @param {any[]} monomersLibObject
+ * @param {ISeqHelper} seqHelper
  * @return {Promise<DG.Widget>} Widget.
  */
-export async function representationsWidget(macroMolecule: DG.Cell, monomersLibObject: any[]): Promise<DG.Widget> {
+export async function representationsWidget(
+  macroMolecule: DG.Cell, monomersLibObject: any[], seqHelper: ISeqHelper
+): Promise<DG.Widget> {
   const pi = DG.TaskBarProgressIndicator.create('Creating 3D view');
 
   let widgetHost;
   let molBlock3D = '';
   try {
     try {
-      const _atomicCodes = getMolfilesFromSingleSeq(macroMolecule, monomersLibObject);
+      const _atomicCodes = getMolfilesFromSingleSeq(macroMolecule, monomersLibObject, seqHelper);
       const result = '';//await getMacroMol(atomicCodes!);
       const molBlock2D = result[0];
       molBlock3D = (await grok.functions.call('Bio:Embed', {molBlock2D})) as unknown as string;

package/src/tests/detectors-custom-notation-tests.ts

@@ -1,37 +0,0 @@
-import * as grok from 'datagrok-api/grok';
-import * as ui from 'datagrok-api/ui';
-import * as DG from 'datagrok-api/dg';
-
-import {category, test} from '@datagrok-libraries/utils/src/test';
-import {ALIGNMENT, ALPHABET, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
-
-import {_testNeg, _testPos, DetectorTestData, DfReaderFunc, PosCol} from './utils/detectors-utils';
-
-category('detectors: custom', () => {
-  const tests: DetectorTestData = {
-    'cyclized1': {
-      csv: `n,seq
-1,R-F-C(1)-T-G-H-F-Y-G-H-F-Y-G-H-F-Y-P-C(1)-meI
-2,C(1)-T-G-H-F-Y-P-C(1)-meI
-3,R-F-C(1)-T-G-H-F-Y-P-C(1)
-4,C(1)-T-G-H-F-H-P-C(1)
-5,R-F-D(2)-T-G-H-F-Y-P-NH2(2)
-6,R-F-aG(3)-T-G-H-F-Y-P-azG(3)-meI`,
-      pos: {'seq': new PosCol(NOTATION.CUSTOM, ALIGNMENT.SEQ, ALPHABET.UN, 13, true, '-')}
-    },
-  };
-
-  for (const [testName, testData] of Object.entries(tests)) {
-    test(`${testName}`, async () => {
-      const reader: DfReaderFunc = async (): Promise<DG.DataFrame> => {
-        return DG.DataFrame.fromCsv(testData.csv);
-      };
-      for (const negColName of testData.neg ?? [])
-        await _testNeg(reader, negColName);
-      for (const [posColName, posCol] of Object.entries(testData.pos ?? {})) {
-        await _testPos(reader, posColName, posCol.units, posCol.aligned,
-          posCol.alphabet, posCol.alphabetSize, posCol.alphabetIsMultichar, posCol.separator);
-      }
-    });
-  }
-});

package/src/utils/cyclized.ts

@@ -1,89 +0,0 @@
-import * as grok from 'datagrok-api/grok';
-import * as ui from 'datagrok-api/ui';
-import * as DG from 'datagrok-api/dg';
-
-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 {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;
-  public readonly splitter: SplitterFunc;
-
-  constructor(
-    public readonly separator: string
-  ) {
-    this.separatorSplitter = getSplitterWithSeparator(this.separator);
-    this.splitter = this._splitter.bind(this);
-  }
-
-  private _splitter(seq: string): ISeqSplitted {
-    const baseSS: ISeqSplitted = this.separatorSplitter(seq);
-    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>> {
-    const polyToolPackageName: string = 'SequenceTranslator';
-
-    const funcList = DG.Func.find({package: polyToolPackageName, name: 'polyToolConvert2'});
-    if (funcList.length == 0)
-      throw new Error(`Package '${polyToolPackageName}' must be installed for Cyclized notation provider.`);
-    const func = funcList[0];
-
-    const ptConvertCall = await func.prepare({table: seqCol.dataFrame, seqCol: seqCol, ...options});
-
-    const editorFunc = DG.Func.find({package: polyToolPackageName, name: 'getPolyToolConvertEditor'})[0];
-    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)[];
-
-  override getCanonical(posIdx: number): string {
-    if (this.isGap(posIdx)) return GAP_SYMBOL;
-
-    let cmRes: string | null = this.seqCList[posIdx];
-    if (cmRes === null) {
-      const om = this.getOriginal(posIdx);
-      cmRes = om;
-      if (om[om.length - 1] === ')')
-        cmRes = this.seqCList[posIdx] = om.replace(/\(\d+\)$/, '');
-    }
-    return cmRes;
-  }
-
-  constructor(seqOList: SeqSplittedBase, gapOriginalMonomer: string) {
-    super(seqOList, gapOriginalMonomer);
-    this.seqCList = new Array<string | null>(this.length).fill(null);
-  }
-}

package/src/utils/dimerized.ts

@@ -1,10 +0,0 @@
-import * as grok from 'datagrok-api/grok';
-import * as ui from 'datagrok-api/ui';
-import * as DG from 'datagrok-api/dg';
-
-import {CyclizedNotationProvider} from './cyclized';
-
-
-export class DimerizedNotationProvider extends CyclizedNotationProvider {
-
-}