@datagrok/bio 2.15.13 → 2.16.2

package/src/utils/get-region-func-editor.ts

@@ -3,7 +3,7 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 
 import {_package} from '../package';
 
@@ -33,12 +33,14 @@ export class GetRegionFuncEditor {
   }();
 
   constructor(
-    private readonly call: DG.FuncCall
+    private readonly call: DG.FuncCall,
+    private readonly seqHelper: ISeqHelper,
   ) {
     const getDesc = (paramName: string) => this.call.inputParams[paramName].property.description;
 
     this.inputs.table = ui.input.table('Table', {value: this.call.inputParams['table'].value ?? grok.shell.tv.dataFrame});
 
+    //@formatter:off
     const seqColValue = this.call.inputParams['sequence'].value ??
       this.inputs.table.value!.columns.bySemType(DG.SEMTYPE.MACROMOLECULE);
     this.inputs.sequence = ui.input.column('Sequence', {table: grok.shell.tv.dataFrame, value: seqColValue,
@@ -52,6 +54,7 @@ export class GetRegionFuncEditor {
     this.inputs.name = ui.input.string('Column name', {value: this.getDefaultName(),
       onValueChanged: this.nameInputChanged.bind(this), clearIcon: true});
     this.inputs.name.onInput.subscribe(() => this.nameInputInput.bind(this)); // To catch clear event
+    //@formatter:on
 
     // tooltips
     for (const paramName in this.call.inputParams) {
@@ -65,7 +68,7 @@ export class GetRegionFuncEditor {
 
   private sequenceInputChanged(): void {
     const seqCol = this.inputs.sequence.value;
-    const sh = seqCol ? SeqHandler.forColumn(seqCol) : null;
+    const sh = seqCol ? this.seqHelper.getSeqHandler(seqCol) : null;
     this.updateRegionItems();
     this.updateStartEndInputItems();
     this.updateRegion(true);
@@ -84,7 +87,7 @@ export class GetRegionFuncEditor {
         this.inputs.start.value = reg?.start;
         this.inputs.end.value = reg?.end;
       } else {
-        const sh = SeqHandler.forColumn(this.inputs.sequence.value!);
+        const sh = this.seqHelper.getSeqHandler(this.inputs.sequence.value!);
         this.inputs.start.value = sh.posList[0];
         this.inputs.end.value = sh.posList[sh.posList.length - 1];
       }
@@ -117,7 +120,7 @@ export class GetRegionFuncEditor {
 
   private updateStartEndInputItems(): void {
     const seqCol = this.inputs.sequence.value;
-    const sh = seqCol ? SeqHandler.forColumn(seqCol) : null;
+    const sh = seqCol ? this.seqHelper.getSeqHandler(seqCol) : null;
 
     const startSE = (this.inputs.start.input as HTMLSelectElement);
     const endSE = (this.inputs.end.input as HTMLSelectElement);

package/src/utils/get-region.ts

@@ -2,11 +2,10 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
-import {TaskBarProgressIndicator} from 'datagrok-api/dg';
+import {_package} from '../package';
 
 export function getRegionUI(col: DG.Column<string>): void {
-  const sh = SeqHandler.forColumn(col);
+  const sh = _package.seqHelper.getSeqHandler(col);
 
   const nameInput = ui.input.string('Name', {value: ''});
   const startPositionInput = ui.input.choice('Start Position', {value: sh.posList[0], items: sh.posList,
@@ -23,7 +22,7 @@ export function getRegionUI(col: DG.Column<string>): void {
     startPositionInput,
     endPositionInput,
   ])).onOK(() => {
-    const pi = TaskBarProgressIndicator.create('Getting region...');
+    const pi = DG.TaskBarProgressIndicator.create('Getting region...');
     try {
       const name: string = nameInput.value ?? getDefaultName();
       const regCol = getRegionDo(col, name, startPositionInput.value, endPositionInput.value);
@@ -39,7 +38,7 @@ export function getRegionUI(col: DG.Column<string>): void {
 export function getRegionDo(
   col: DG.Column<string>, startPosName: string | null, endPosName: string | null, name: string | null
 ): DG.Column<string> {
-  const sh = SeqHandler.forColumn(col);
+  const sh = _package.seqHelper.getSeqHandler(col);
 
   let startPosIdx: number | null = null;
   let endPosIdx: number | null = null;

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

@@ -21,8 +21,8 @@ export class Helm {
    * complex polymer scope) */
   readonly bondData: Bond[][];
 
-  private simplePolymers: SimplePolymer[];
-  private connectionList?: ConnectionList;
+  public readonly simplePolymers: SimplePolymer[];
+  public readonly connectionList?: ConnectionList;
 
   /** Maps global monomer index to r-group ids (starting from 1) participating
    * in connection */
@@ -74,8 +74,8 @@ export class Helm {
     });
   }
 
-  private getMonomerIdxShifts(): {[simplePolymerId: string]: number} {
-    const result: {[simplePolymerId: string]: number} = {};
+  private getMonomerIdxShifts(): { [simplePolymerId: string]: number } {
+    const result: { [simplePolymerId: string]: number } = {};
     let shift = 0;
     this.simplePolymers.forEach((simplePolymer) => {
       result[simplePolymer.id] = shift;

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

@@ -6,14 +6,14 @@ import {IMonomerLibBase} from '@datagrok-libraries/bio/src/types';
 
 import {SeqHelper} from '../seq-helper';
 
-import {_package, getMonomerLib} from '../../package';
+import {_package} from '../../package';
 
 /** Translate HELM column into molfile column and append to the dataframe */
 export async function getMolColumnFromHelm(
   df: DG.DataFrame, helmCol: DG.Column<string>, chiralityEngine: boolean = true, monomerLib: IMonomerLibBase
 ): Promise<DG.Column<string>> {
-  const seqHelper = await SeqHelper.getInstance();
-  const converter = seqHelper.getHelmToMolfileConverter(monomerLib);
+  const seqHelper: SeqHelper = _package.seqHelper as SeqHelper;
+  const converter = await seqHelper.getHelmToMolfileConverter(monomerLib);
   const molCol = converter.convertToRdKitBeautifiedMolfileColumn(helmCol, chiralityEngine, _package.rdKitModule, monomerLib);
   molCol.semType = DG.SEMTYPE.MOLECULE;
   return molCol;
@@ -22,9 +22,8 @@ export async function getMolColumnFromHelm(
 export async function getSmilesColumnFromHelm(
   helmCol: DG.Column<string>
 ): Promise<DG.Column<string>> {
-  const seqHelper = await SeqHelper.getInstance();
-  const monomerLib = getMonomerLib();
-  const converter = seqHelper.getHelmToMolfileConverter(monomerLib);
+  const seqHelper: SeqHelper = _package.seqHelper as SeqHelper;
+  const converter = await seqHelper.getHelmToMolfileConverter(_package.monomerLib);
   const smilesCol = converter.convertToSmiles(helmCol);
   smilesCol.semType = DG.SEMTYPE.MOLECULE;
   return smilesCol;

package/src/utils/macromolecule-column-widget.ts

@@ -3,7 +3,7 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {TAGS as wlTAGS} from '@datagrok-libraries/bio/src/viewers/web-logo';
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 
 import {WebLogoViewer} from '../viewers/web-logo-viewer';
 
@@ -13,18 +13,17 @@ import {_package} from '../package';
 export class MacromoleculeColumnWidget extends DG.Widget {
   private viewed: boolean = false;
 
-  private readonly seqCol: DG.Column<string>;
-
   private wlViewer: WebLogoViewer | null = null;
 
-  constructor(seqCol: DG.Column<string>) {
+  constructor(
+    private readonly seqCol: DG.Column<string>,
+    private readonly seqHelper: ISeqHelper,
+  ) {
     super(ui.divV([]));
-
-    this.seqCol = seqCol;
   }
 
   async init(): Promise<void> {
-    const sh = SeqHandler.forColumn(this.seqCol);
+    const sh = this.seqHelper.getSeqHandler(this.seqCol);
     const pkgTooltipWebLogo = _package.properties.tooltipWebLogo;
     const colTooltipWebLogo = this.seqCol.getTag(wlTAGS.tooltipWebLogo);
 

package/src/utils/monomer-cell-renderer-base.ts

@@ -5,13 +5,15 @@ import * as ui from 'datagrok-api/ui';
 import {getMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {CellRendererBackBase} from '@datagrok-libraries/bio/src/utils/cell-renderer-back-base';
 import {IMonomerLibBase} from '@datagrok-libraries/bio/src/types/index';
+import {ISeqHelper, getSeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 
 import {_package} from '../package';
 
 export abstract class CellRendererWithMonomerLibBackBase extends CellRendererBackBase<string> {
   protected monomerLib: IMonomerLibBase | null = null;
+  protected seqHelper: ISeqHelper | null = null;
 
-  constructor(
+  protected constructor(
     gridCol: DG.GridColumn | null,
     tableCol: DG.Column<string>,
   ) {
@@ -26,5 +28,10 @@ export abstract class CellRendererWithMonomerLibBackBase extends CellRendererBac
         this.gridCol?.grid?.invalidate();
       }));
     });
+    getSeqHelper().then((seqHelper) => {
+      this.seqHelper = seqHelper;
+      this.dirty = true;
+      this.gridCol?.grid?.invalidate();
+    });
   }
 }

package/src/utils/monomer-lib/lib-manager.ts

@@ -35,7 +35,8 @@ export class MonomerLibManager implements IMonomerLibHelper {
 
   public get eventManager(): IMonomerLibFileEventManager { return this._eventManager; }
 
-  public async awaitLoaded(timeout: number = 5000): Promise<void> {
+  public async awaitLoaded(timeout: number = Infinity): Promise<void> {
+    timeout = timeout === Infinity ? 1 * 60000 : timeout; // Limit the max lib loaded timeout
     return await Promise.race([
       (async () => {
         const fileManager = await this.getFileManager();
@@ -273,7 +274,7 @@ export class MonomerLibManager implements IMonomerLibHelper {
   /** Changes userLibSettings set only HELMCoreLibrary.json, polytool-lib.json */
   async loadMonomerLibForTests(): Promise<void> {
     await setUserLibSettings(LIB_SETTINGS_FOR_TESTS);
-    await this.awaitLoaded();
+    await this.awaitLoaded(10000);
     await this.loadMonomerLib(true); // load default libraries
   }
 

package/src/utils/monomer-lib/monomer-colors.ts

@@ -8,20 +8,20 @@ import {HelmType} from '@datagrok-libraries/bio/src/helm/types';
 export const naturalMonomerColors = {
   [HelmTypes.BASE]: {
     // Chromatogram palette  // HELMWebEditor monomerColors
-    A: "green",              // "#A0A0FF",
-    G: "black",              // "#FF7070",
-    T: "red",                // "#A0FFA0",
-    C: "blue",               // "#FF8C4B",
-    U: "red",                // "#FF8080"
+    A: "#20E040",            // "#A0A0FF",
+    G: "#040404",            // "#FF7070",
+    T: "#FF8080",            // "#A0FFA0",
+    C: "#2060FF",            // "#FF8C4B",
+    U: "#FF8080",            // "#FF8080"
   },
 
   [HelmTypes.NUCLEOTIDE]: {
     // Chromatogram palette  // HELMWebEditor monomerColors
-    A: "green",              // "#A0A0FF",
-    G: "black",              // "#FF7070",
-    T: "red",                // "#A0FFA0",
-    C: "blue",               // "#FF8C4B",
-    U: "red",                // "#FF8080"
+    A: "#20E040",            // "#A0A0FF",
+    G: "#040404",            // "#FF7070",
+    T: "#FF8080",            // "#A0FFA0",
+    C: "#2060FF",            // "#FF8C4B",
+    U: "#FF8080",            // "#FF8080"
   },
 
   [HelmTypes.LINKER]: {

package/src/utils/monomer-lib/monomer-lib-base.ts

@@ -42,11 +42,16 @@ export class MonomerLibBase implements IMonomerLibBase {
 
   constructor(
     protected _monomers: MonomerLibDataType,
+    public readonly source: string,
   ) {
     this._isEmpty = !this._monomers || Object.keys(this._monomers).length === 0 ||
       Object.entries(this._monomers).every(([_, ptMonomers]) => Object.keys(ptMonomers).length === 0);
   }
 
+  getMonomerSymbolsByType(polymerType: PolymerType): string[] {
+    return Object.keys(this._monomers[polymerType]);
+  }
+
   /** Creates missing {@link Monomer} */
   addMissingMonomer(polymerType: PolymerType, monomerSymbol: string): Monomer {
     let mSet = this._monomers[polymerType];
@@ -212,7 +217,7 @@ export class MonomerLibBase implements IMonomerLibBase {
       if (rgbM)
         return [parseInt(rgbM[1]), parseInt(rgbM[2]), parseInt(rgbM[3])];
 
-      const n = DG.Color.fromHtml(colors.textcolor!);
+      const n = DG.Color.fromHtml(html);
       return [DG.Color.r(n), DG.Color.g(n), DG.Color.b(n)];
     };
 

package/src/utils/monomer-lib/monomer-lib.ts

@@ -39,10 +39,10 @@ export class MonomerLib extends MonomerLibBase implements IMonomerLib {
 
   constructor(
     monomers: MonomerLibDataType,
-    public readonly source: string | undefined = undefined,
+    source: string,
     public readonly error: string | undefined = undefined,
   ) {
-    super(monomers);
+    super(monomers, source);
     for (const [_monomerType, monomersOfType] of Object.entries(this._monomers)) {
       for (const [_monomerSymbol, monomer] of Object.entries(monomersOfType))
         monomer.lib = this;
@@ -112,10 +112,6 @@ export class MonomerLib extends MonomerLibBase implements IMonomerLib {
     return res;
   }
 
-  getMonomerSymbolsByType(polymerType: PolymerType): string[] {
-    return Object.keys(this._monomers[polymerType]);
-  }
-
   /** Get a list of monomers with specified element attached to specified
    * R-group
    * WARNING: RGroup numbering starts from 1, not 0*/
@@ -241,21 +237,31 @@ export class MonomerLib extends MonomerLibBase implements IMonomerLib {
     return resStr;
   }
 
-  override(data: MonomerLibData): IMonomerLibBase {
-    return new OverriddenMonomerLib(data, this);
+  override(data: MonomerLibData, source: string): IMonomerLibBase {
+    return new OverriddenMonomerLib(data, source, this);
   }
 }
 
 class OverriddenMonomerLib extends MonomerLibBase {
   constructor(
     private readonly data: MonomerLibData,
+    source: string,
     private readonly base: MonomerLibBase
   ) {
-    super(data);
+    super(data, source);
   }
 
   get onChanged(): Observable<any> { return this.base.onChanged; }
 
+  override getMonomerSymbolsByType(polymerType: PolymerType): string[] {
+    const resList = this.base.getMonomerSymbolsByType(polymerType);
+    for (const overrideSymbol of Object.keys(this.data[polymerType] ?? {})) {
+      if (!resList.includes(overrideSymbol))
+        resList.push(overrideSymbol);
+    }
+    return resList;
+  }
+
   addMissingMonomer(polymerType: PolymerType, monomerSymbol: string): Monomer {
     return this.base.addMissingMonomer(polymerType, monomerSymbol);
   }

package/src/utils/multiple-sequence-alignment-ui.ts

@@ -5,21 +5,20 @@ import * as ui from 'datagrok-api/ui';
 import {ColumnInputOptions} from '@datagrok-libraries/utils/src/type-declarations';
 import {delay} from '@datagrok-libraries/utils/src/test';
 import {ALPHABET, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
 
 import {MsaWarning, runKalign} from './multiple-sequence-alignment';
 import {pepseaMethods, runPepsea} from './pepsea';
-import {checkInputColumnUI} from './check-input-column';
-import {multipleSequenceAlginmentUIOptions} from './types';
+import {checkInputColumn} from './check-input-column';
+import {MultipleSequenceAlignmentUIOptions} from './types';
 import {kalignVersion, msaDefaultOptions} from './constants';
 import {awaitContainerStart} from './docker';
 
-import {_package} from '../package';
-
 import '../../css/msa.css';
+import {_package} from '../package';
 
 export async function multipleSequenceAlignmentUI(
-  options: multipleSequenceAlginmentUIOptions = {},
+  options: MultipleSequenceAlignmentUIOptions, seqHelper: ISeqHelper,
 ): Promise<DG.Column> {
   return new Promise(async (resolve, reject) => {
     options.clustersCol ??= null;
@@ -70,20 +69,22 @@ export async function multipleSequenceAlignmentUI(
 
     let prevSeqCol = seqCol;
     const colInput = ui.input.column(
-      'Sequence', {table: table, value: seqCol, onValueChanged: async (value: DG.Column<any>) => {
-        if (!value || value.semType !== DG.SEMTYPE.MACROMOLECULE) {
-          okBtn.disabled = true;
-          await delay(0); // to
-          colInput.value = prevSeqCol as DG.Column<string>;
-          return;
-        }
-        prevSeqCol = value;
-        okBtn.disabled = false;
-        performAlignment = await onColInputChange(
-          colInput.value, table, pepseaInputRootStyles, kalignInputRootStyles,
-          methodInput, clustersColInput, gapOpenInput, gapExtendInput, terminalGapInput,
-        );
-      }, filter: (col: DG.Column) => col.semType === DG.SEMTYPE.MACROMOLECULE} as ColumnInputOptions
+      'Sequence', {
+        table: table, value: seqCol, onValueChanged: async (value: DG.Column<any>) => {
+          if (!value || value.semType !== DG.SEMTYPE.MACROMOLECULE) {
+            okBtn.disabled = true;
+            await delay(0); // to
+            colInput.value = prevSeqCol as DG.Column<string>;
+            return;
+          }
+          prevSeqCol = value;
+          okBtn.disabled = false;
+          performAlignment = await onColInputChange(
+            colInput.value, table, seqHelper, pepseaInputRootStyles, kalignInputRootStyles,
+            methodInput, clustersColInput, gapOpenInput, gapExtendInput, terminalGapInput,
+          );
+        }, filter: (col: DG.Column) => col.semType === DG.SEMTYPE.MACROMOLECULE
+      } as ColumnInputOptions
     ) as DG.InputBase<DG.Column<string>>;
     colInput.setTooltip('Sequences column to use for alignment');
     const clustersColInput = ui.input.column('Clusters', {table: table, value: options.clustersCol!});
@@ -103,7 +104,7 @@ export async function multipleSequenceAlignmentUI(
     //if column is specified (from tests), run alignment and resolve with the result
     if (options.col) {
       performAlignment = await onColInputChange(
-        options.col, table, pepseaInputRootStyles, kalignInputRootStyles,
+        options.col, table, seqHelper, pepseaInputRootStyles, kalignInputRootStyles,
         methodInput, clustersColInput, gapOpenInput, gapExtendInput, terminalGapInput,
       );
       await onDialogOk(colInput, table, performAlignment, resolve, reject);
@@ -146,7 +147,7 @@ async function onDialogOk(
 
 
 async function onColInputChange(
-  col: DG.Column<string>, table: DG.DataFrame,
+  col: DG.Column<string>, table: DG.DataFrame, seqHelper: ISeqHelper,
   pepseaInputRootStyles: CSSStyleDeclaration[], kalignInputRootStyles: CSSStyleDeclaration[],
   methodInput: DG.InputBase<string | null>, clustersColInput: DG.InputBase<DG.Column<any> | null>,
   gapOpenInput: DG.InputBase<number | null>, gapExtendInput: DG.InputBase<number | null>,
@@ -157,20 +158,19 @@ async function onColInputChange(
       return;
     const unusedName = table.columns.getUnusedName(`msa(${col.name})`);
 
-    if (checkInputColumnUI(col, col.name,
-      [NOTATION.FASTA, NOTATION.SEPARATOR], [ALPHABET.DNA, ALPHABET.RNA, ALPHABET.PT], false)
+    if (checkInputColumn(col, col.name, seqHelper,
+      [NOTATION.FASTA, NOTATION.SEPARATOR], [ALPHABET.DNA, ALPHABET.RNA, ALPHABET.PT])[0]
     ) { // Kalign - natural alphabets. if the notation is separator, convert to fasta and then run kalign
       switchDialog(pepseaInputRootStyles, kalignInputRootStyles, 'kalign');
       gapOpenInput.value = null;
       gapExtendInput.value = null;
       terminalGapInput.value = null;
-      const potentialColSh = SeqHandler.forColumn(col);
+      const potentialColSh = seqHelper.getSeqHandler(col);
       const performCol: DG.Column<string> = potentialColSh.isFasta() ? col :
         potentialColSh.convert(NOTATION.FASTA);
       return async () => await runKalign(performCol, false, unusedName, clustersColInput.value);
-    } else if (checkInputColumnUI(col, col.name,
-      [NOTATION.HELM], [], false)
-    ) { // PepSeA branch - Helm notation or separator notation with unknown alphabets
+    } else if (checkInputColumn(col, col.name, seqHelper, [NOTATION.HELM], [])[0]) {
+      // PepSeA branch - Helm notation or separator notation with unknown alphabets
       switchDialog(pepseaInputRootStyles, kalignInputRootStyles, 'pepsea');
       gapOpenInput.value ??= msaDefaultOptions.pepsea.gapOpen;
       gapExtendInput.value ??= msaDefaultOptions.pepsea.gapExtend;
@@ -180,9 +180,9 @@ async function onColInputChange(
         return runPepsea(col, unusedName, methodInput.value!,
           gapOpenInput.value!, gapExtendInput.value!, clustersColInput.value);
       };
-    } else if (checkInputColumnUI(col, col.name, [NOTATION.SEPARATOR], [ALPHABET.UN], false)) {
+    } else if (checkInputColumn(col, col.name, seqHelper, [NOTATION.SEPARATOR], [ALPHABET.UN])[0]) {
       //if the column is separator with unknown alphabet, it might be helm. check if it can be converted to helm
-      const potentialColSh = SeqHandler.forColumn(col);
+      const potentialColSh = seqHelper.getSeqHandler(col);
       const helmCol = potentialColSh.convert(NOTATION.HELM);
       switchDialog(pepseaInputRootStyles, kalignInputRootStyles, 'pepsea');
       gapOpenInput.value ??= msaDefaultOptions.pepsea.gapOpen;

package/src/utils/save-as-fasta.ts

@@ -3,13 +3,16 @@ import * as ui from 'datagrok-api/ui';
 import * as grok from 'datagrok-api/grok';
 
 import wu from 'wu';
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+
 import {ISeqSplitted} from '@datagrok-libraries/bio/src/utils/macromolecule/types';
+import {ISeqHandler} from '@datagrok-libraries/bio/src/utils/macromolecule/seq-handler';
+
+import {_package} from '../package';
 
 const FASTA_LINE_WIDTH = 60;
 
 /** Shows dialog to select id columns list and seq column, builds and downloads FASTA content */
-export function saveAsFastaUI() {
+export function saveAsFastaUI(): void {
   // Use grid for column order adjusted by user
   const grid: DG.Grid = grok.shell.tv.grid;
 
@@ -20,23 +23,27 @@ export function saveAsFastaUI() {
     .find((gcol: DG.GridColumn) => gcol.name.toLowerCase().indexOf('id') !== -1);
   const idDefaultValue = defaultIdGCol ? [defaultIdGCol.name] : [];
 
-  const idGColListInput = ui.input.multiChoice('Seq id columns', {value: idDefaultValue,
-    items: idGColList.map((gcol: DG.GridColumn) => gcol.name)});
+  const idGColListInput = ui.input.multiChoice('Seq id columns', {
+    value: idDefaultValue,
+    items: idGColList.map((gcol: DG.GridColumn) => gcol.name)
+  });
 
   const seqGColList: DG.GridColumn[] = wu.count(0).take(grid.columns.length)/* range rom 0 to grid.columns.length */
     .map((colI: number) => grid.columns.byIndex(colI)!)
     .filter((gc: DG.GridColumn) => {
       const col: DG.Column | null = gc.column;
       if (col && col.semType === DG.SEMTYPE.MACROMOLECULE) {
-        const sh = SeqHandler.forColumn(col);
+        const sh = _package.seqHelper.getSeqHandler(col);
         return sh.isFasta();
       }
       return false;
     }).toArray();
 
   const seqDefaultValue = seqGColList.length > 0 ? seqGColList[0].name : [];
-  const seqColInput = ui.input.choice('Seq column', {value: seqDefaultValue,
-    items: seqGColList.map((gCol: DG.GridColumn) => gCol.name)});
+  const seqColInput = ui.input.choice('Seq column', {
+    value: seqDefaultValue,
+    items: seqGColList.map((gCol: DG.GridColumn) => gCol.name)
+  });
 
   const lineWidthInput = ui.input.int('FASTA line width', {value: FASTA_LINE_WIDTH});
 
@@ -56,7 +63,8 @@ export function saveAsFastaUI() {
       if (!valueSeqCol)
         grok.shell.warning(`Seq column is mandatory to save as FASTA.`);
 
-      const resFastaTxt: string = saveAsFastaDo(valueIdColList, valueSeqCol!, valueLineWidth);
+      const seqHandler = _package.seqHelper.getSeqHandler(valueSeqCol!);
+      const resFastaTxt: string = saveAsFastaDo(valueIdColList, seqHandler, valueLineWidth);
 
       const aEl: HTMLAnchorElement = document.createElement('a');
       aEl.setAttribute('href', `data:text/plain;charset=utf-8,${encodeURIComponent(resFastaTxt)}`);
@@ -75,17 +83,16 @@ export function saveAsFastaUI() {
  * @return {string} FASTA content
  */
 export function saveAsFastaDo(
-  idColList: DG.Column[], seqCol: DG.Column, lineWidth: number = FASTA_LINE_WIDTH, lineSeparator: string = '\n',
+  idColList: DG.Column[], seqHandler: ISeqHandler, lineWidth: number = FASTA_LINE_WIDTH, lineSeparator: string = '\n',
 ): string {
-  const sh = SeqHandler.forColumn(seqCol);
   const fastaLines: string[] = [];
 
-  for (let rowIdx: number = 0; rowIdx < seqCol.length; rowIdx++) {
+  for (let rowIdx: number = 0; rowIdx < seqHandler.length; rowIdx++) {
     // multiple identifiers separated by vertical bars
     // https://en.wikipedia.org/wiki/FASTA_format
 
     const seqId: string = idColList.map((col) => col.get(rowIdx).toString()).join('|');
-    const srcSS = sh.getSplitted(rowIdx);
+    const srcSS = seqHandler.getSplitted(rowIdx);
     const seqLineList: string[] = wrapSequence(srcSS, lineWidth);
 
     fastaLines.push(`>${seqId}${lineSeparator}`);