@datagrok/bio 2.15.13 → 2.16.2

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

@@ -15,9 +15,10 @@ 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';
+import {Column} from 'datagrok-api/dg';
+import {NOTATION, TAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
 type SeqHelperWindowType = Window & { $seqHelperPromise?: Promise<SeqHelper> };
 declare const window: SeqHelperWindowType;
@@ -25,12 +26,22 @@ 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, this);
+  }
+
+  getSeqMonomers(seqCol: Column<string>): string[] {
+    const sh = this.getSeqHandler(seqCol);
+    return Object.keys(sh.stats.freq);
+  }
+
+  // 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 +52,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
 
@@ -86,17 +97,30 @@ 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;
+  public setUnitsToFastaColumn(uh: SeqHandler) {
+    if (uh.column.semType !== DG.SEMTYPE.MACROMOLECULE || uh.column.meta.units !== NOTATION.FASTA)
+      throw new Error(`The column of notation '${NOTATION.FASTA}' must be '${DG.SEMTYPE.MACROMOLECULE}'.`);
+
+    uh.column.meta.units = NOTATION.FASTA;
+    SeqHandler.setTags(uh);
+  }
+
+  public setUnitsToSeparatorColumn(uh: SeqHandler, separator?: string) {
+    if (uh.column.semType !== DG.SEMTYPE.MACROMOLECULE || uh.column.meta.units !== NOTATION.SEPARATOR)
+      throw new Error(`The column of notation '${NOTATION.SEPARATOR}' must be '${DG.SEMTYPE.MACROMOLECULE}'.`);
+    if (!separator)
+      throw new Error(`The column of notation '${NOTATION.SEPARATOR}' must have the separator tag.`);
+
+    uh.column.meta.units = NOTATION.SEPARATOR;
+    uh.column.setTag(TAGS.separator, separator);
+    SeqHandler.setTags(uh);
+  }
+
+  public setUnitsToHelmColumn(uh: SeqHandler) {
+    if (uh.column.semType !== DG.SEMTYPE.MACROMOLECULE)
+      throw new Error(`The column of notation '${NOTATION.HELM}' must be '${DG.SEMTYPE.MACROMOLECULE}'`);
+
+    uh.column.meta.units = NOTATION.HELM;
+    SeqHandler.setTags(uh);
   }
 }

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-helm.ts

@@ -10,6 +10,7 @@ import {getHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 import {ILogger} from '@datagrok-libraries/bio/src/utils/logger';
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
 import {delay} from '@datagrok-libraries/utils/src/test';
+import {ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 
 import {updateDivInnerHTML} from '../utils/ui-utils';
 import {helmSubstructureSearch} from '../substructure-search/substructure-search';
@@ -32,7 +33,9 @@ export class HelmBioFilter extends BioFilterBase<BioFilterProps> /* implements I
 
   get type(): string { return 'HelmBioFilter'; }
 
-  constructor() {
+  constructor(
+    private readonly seqHelper: ISeqHelper,
+  ) {
     super();
     this.logger = _package.logger;
   }
@@ -138,7 +141,7 @@ export class HelmBioFilter extends BioFilterBase<BioFilterProps> /* implements I
     _package.logger.debug(`${logPrefix}, start`);
     try {
       await delay(10);
-      const res = await helmSubstructureSearch(this.props.substructure, column);
+      const res = await helmSubstructureSearch(this.props.substructure, column, this.seqHelper);
       return res;
     } finally {
       _package.logger.debug(`${logPrefix}, end`);

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

@@ -16,18 +16,16 @@ 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';
+import {ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 
 import {helmSubstructureSearch, linearSubstructureSearch} from '../substructure-search/substructure-search';
 import {updateDivInnerHTML} from '../utils/ui-utils';
 import {BioFilterBase, BioFilterProps, IBioFilter, IFilterProps} from './bio-substructure-filter-types';
 import {HelmBioFilter} from './bio-substructure-filter-helm';
 
-import {_package} from '../package';
-
 const FILTER_SYNC_EVENT: string = 'bio-substructure-filter';
 
 class FilterState {
@@ -56,7 +54,6 @@ export class BioSubstructureFilter extends DG.Filter implements IRenderer {
   readonly loader: HTMLDivElement;
   notation: string | undefined = undefined;
 
-  readonly logger: ILogger;
   readonly filterSyncer: PromiseSyncer;
 
   get calculating(): boolean { return this.loader.style.display == 'initial'; }
@@ -88,22 +85,15 @@ export class BioSubstructureFilter extends DG.Filter implements IRenderer {
     return res;
   }
 
-  constructor() {
+  constructor(
+    private readonly seqHelper: ISeqHelper,
+    private logger: ILogger
+  ) {
     super();
     this.root = ui.divV([]);
     this.loader = ui.loader();
     this.calculating = false;
-    this.filterSyncer = new PromiseSyncer(this.logger = _package.logger);
-
-    return new Proxy(this, {
-      set(target: any, key, value) {
-        if (key === 'column') {
-          const k = 42;
-        }
-        target[key] = value;
-        return true;
-      }
-    });
+    this.filterSyncer = new PromiseSyncer(this.logger);
   }
 
   private static filterCounter: number = -1;
@@ -125,13 +115,13 @@ 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 = this.seqHelper.getSeqHandler(this.column!);
       this.columnName ??= this.column?.name;
       this.notation ??= this.column?.meta.units!;
 
       this.bioFilter = this.notation === NOTATION.FASTA ?
         new FastaBioFilter() : this.notation === NOTATION.SEPARATOR ?
-          new SeparatorBioFilter(this.column!.getTag(bioTAGS.separator)) : new HelmBioFilter();
+          new SeparatorBioFilter(this.column!.getTag(bioTAGS.separator)) : new HelmBioFilter(this.seqHelper);
       this.root.appendChild(this.bioFilter!.filterPanel);
       this.root.appendChild(this.loader);
       await this.bioFilter.attach(); // may await waitForElementInDom
@@ -201,7 +191,7 @@ export class BioSubstructureFilter extends DG.Filter implements IRenderer {
 
   private fireFilterSync(): void {
     const logPrefix = `${this.filterToLog()}.fireFilterSync()`;
-    _package.logger.debug(`${logPrefix}, ` +
+    this.logger.debug(`${logPrefix}, ` +
       `bioFilter = ${!!this.bioFilter ? this.bioFilter.constructor.name : 'null'}` +
       (!!this.bioFilter ? `, props = ${JSON.stringify(this.bioFilter!.saveProps())}` : ''));
 
@@ -219,7 +209,7 @@ export class BioSubstructureFilter extends DG.Filter implements IRenderer {
   bioFilterOnChangedDebounced(): void {
     if (!this.dataFrame) return; // Debounced event can be handled postponed
     const logPrefix = `${this.filterToLog()}.bioFilterOnChangedDebounced()`;
-    _package.logger.debug(`${logPrefix}, start, ` +
+    this.logger.debug(`${logPrefix}, start, ` +
       `isFiltering = ${this.isFiltering}, ` +
       `props = ${JSON.stringify(this.bioFilter!.saveProps())}`);
 
@@ -236,22 +226,22 @@ export class BioSubstructureFilter extends DG.Filter implements IRenderer {
     this.filterSyncer.sync(logPrefix, async () => {
       this.calculating = true;
       try {
-        _package.logger.debug(`${logPrefix}, before substructureSearch`);
+        this.logger.debug(`${logPrefix}, before substructureSearch`);
         this.bitset = await this.bioFilter?.substructureSearch(this.column!)!;
-        _package.logger.debug(`${logPrefix}, after substructureSearch`);
+        this.logger.debug(`${logPrefix}, after substructureSearch`);
         this.calculating = false;
         this.fireFilterSync();
         this.dataFrame?.rows.requestFilter();
       } finally {
         this.calculating = false;
-        _package.logger.debug(`${logPrefix}, end`);
+        this.logger.debug(`${logPrefix}, end`);
       }
     });
   }
 
   grokEventsOnResetFilterRequest(): void {
     const logPrefix = `${this.filterToLog()}.grokEventsOnResetFilterRequest()`;
-    _package.logger.debug(`${logPrefix}`);
+    this.logger.debug(`${logPrefix}`);
     this.bioFilter?.resetFilter();
   }
 

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