@datagrok/bio 2.4.31 → 2.4.40

package/src/utils/monomer-lib.ts

@@ -6,10 +6,17 @@ import {Observable, Subject} from 'rxjs';
 import {IMonomerLib, Monomer} from '@datagrok-libraries/bio/src/types/index';
 import {
   createJsonMonomerLibFromSdf,
-  expectedMonomerData,
-  IMonomerLibHelper
+  IMonomerLibHelper,
 } from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import {HELM_REQUIRED_FIELDS as REQ, HELM_OPTIONAL_FIELDS as OPT} from '@datagrok-libraries/bio/src/utils/const';
+import {_package} from '../package';
 
+const _HELM_REQUIRED_FIELDS_ARRAY = [
+  REQ.SYMBOL, REQ.NAME, REQ.MOLFILE, REQ.AUTHOR, REQ.ID,
+  REQ.RGROUPS, REQ.SMILES, REQ.POLYMER_TYPE, REQ.MONOMER_TYPE, REQ.CREATE_DATE,
+] as const;
+
+const _HELM_OPTIONAL_FIELDS_ARRAY = [OPT.NATURAL_ANALOG, OPT.META] as const;
 // -- Monomer libraries --
 export const LIB_STORAGE_NAME = 'Libraries';
 export const LIB_PATH = 'System:AppData/Bio/libraries/';
@@ -21,8 +28,12 @@ export type LibSettings = {
 }
 
 export async function getLibFileNameList(): Promise<string[]> {
-  const res: string[] = (await grok.dapi.files.list(`${LIB_PATH}`, false, ''))
-    .map((it) => it.fileName);
+  // list files recursively because permissions are available for folders only
+  const res: string[] = await Promise.all((await grok.dapi.files.list(LIB_PATH, true, ''))
+    .map(async (it) => {
+      // Get relative path (to LIB_PATH)
+      return it.fullPath.substring(LIB_PATH.length);
+    }));
   return res;
 }
 
@@ -41,36 +52,39 @@ export async function setUserLibSetting(value: LibSettings): Promise<void> {
 }
 
 export class MonomerLib implements IMonomerLib {
-  private _monomers: { [type: string]: { [name: string]: Monomer } } = {};
+  public readonly error: string | undefined;
+
+  private _monomers: { [polymerType: string]: { [monomerSymbol: string]: Monomer } } = {};
   private _onChanged = new Subject<any>();
 
-  constructor(monomers: { [type: string]: { [name: string]: Monomer } }) {
+  constructor(monomers: { [polymerType: string]: { [monomerSymbol: string]: Monomer } }, error?: string) {
     this._monomers = monomers;
+    this.error = error;
   }
 
-  getMonomer(monomerType: string, monomerName: string): Monomer | null {
-    if (monomerType in this._monomers! && monomerName in this._monomers![monomerType])
-      return this._monomers![monomerType][monomerName];
+  getMonomer(polymerType: string, monomerSymbol: string): Monomer | null {
+    if (polymerType in this._monomers! && monomerSymbol in this._monomers![polymerType])
+      return this._monomers![polymerType][monomerSymbol];
     else
       return null;
   }
 
-  getTypes(): string[] {
+  getPolymerTypes(): string[] {
     return Object.keys(this._monomers);
   }
 
-  getMonomerMolsByType(type: string): { [symbol: string]: string } {
-    const res: { [symbol: string]: string } = {};
+  getMonomerMolsByPolymerType(polymerType: string): { [monomerSymbol: string]: string } {
+    const res: { [monomerSymbol: string]: string } = {};
 
-    Object.keys(this._monomers[type]).forEach((monomerSymbol) => {
-      res[monomerSymbol] = this._monomers[type][monomerSymbol].molfile;
+    Object.keys(this._monomers[polymerType]).forEach((monomerSymbol) => {
+      res[monomerSymbol] = this._monomers[polymerType][monomerSymbol].molfile;
     });
 
     return res;
   }
 
-  getMonomerNamesByType(type: string): string[] {
-    return Object.keys(this._monomers[type]);
+  getMonomerSymbolsByType(polymerType: string): string[] {
+    return Object.keys(this._monomers[polymerType]);
   }
 
   get onChanged(): Observable<any> {
@@ -78,8 +92,8 @@ export class MonomerLib implements IMonomerLib {
   }
 
   private _updateInt(lib: IMonomerLib): void {
-    const typesNew = lib.getTypes();
-    const types = this.getTypes();
+    const typesNew = lib.getPolymerTypes();
+    const types = this.getPolymerTypes();
 
     typesNew.forEach((type) => {
       //could possibly rewrite -> TODO: check duplicated monomer symbol
@@ -87,9 +101,9 @@ export class MonomerLib implements IMonomerLib {
       if (!types.includes(type))
         this._monomers![type] = {};
 
-      const monomers = lib.getMonomerNamesByType(type);
-      monomers.forEach((monomerName) => {
-        this._monomers[type][monomerName] = lib.getMonomer(type, monomerName)!;
+      const monomers = lib.getMonomerSymbolsByType(type);
+      monomers.forEach((monomerSymbol) => {
+        this._monomers[type][monomerSymbol] = lib.getMonomer(type, monomerSymbol)!;
       });
     });
   }
@@ -101,7 +115,7 @@ export class MonomerLib implements IMonomerLib {
 
   public updateLibs(libList: IMonomerLib[], reload: boolean = false): void {
     if (reload) this._monomers = {};
-    for (const lib of libList) this._updateInt(lib);
+    for (const lib of libList) if (!lib.error) this._updateInt(lib);
     this._onChanged.next();
   }
 
@@ -117,35 +131,58 @@ export class MonomerLibHelper implements IMonomerLibHelper {
   /** Protect constructor to prevent multiple instantiation. */
   protected constructor() {}
 
-  /** Singleton monomer library */
+  /** Singleton monomer library
+   * @return {MonomerLibHelper} MonomerLibHelper instance
+   */
   getBioLib(): IMonomerLib {
     return this._monomerLib;
   }
 
-  private loadLibrariesPromise: Promise<void> = Promise.resolve();
+  /** Allows syncing with managing settings/loading libraries */
+  public loadLibrariesPromise: Promise<void> = Promise.resolve();
 
   /** Loads libraries based on settings in user storage {@link LIB_STORAGE_NAME}
    * @param {boolean} reload Clean {@link monomerLib} before load libraries [false]
    */
   async loadLibraries(reload: boolean = false): Promise<void> {
     return this.loadLibrariesPromise = this.loadLibrariesPromise.then(async () => {
-      const [libFileNameList, settings]: [string[], LibSettings] = await Promise.all([
-        getLibFileNameList(),
-        getUserLibSettings()
-      ]);
-      const libs: IMonomerLib[] = await Promise.all(libFileNameList
-        .filter((libFileName) => !settings.exclude.includes(libFileName))
-        .map((libFileName) => {
-          //TODO handle whether files are in place
-          return this.readLibrary(LIB_PATH, libFileName);
-        }));
-      this._monomerLib.updateLibs(libs, reload);
+      // This function is not allowed to throw any exception,
+      // because it will prevent further handling monomer library settings
+      // through blocking this.loadLibrariesPromise
+      try {
+        const [libFileNameList, settings]: [string[], LibSettings] = await Promise.all([
+          getLibFileNameList(),
+          getUserLibSettings(),
+        ]);
+        const libs: IMonomerLib[] = await Promise.all(libFileNameList
+          .filter((libFileName) => !settings.exclude.includes(libFileName))
+          .map((libFileName) => {
+            //TODO handle whether files are in place
+            return this.readLibrary(LIB_PATH, libFileName).catch((err: any) => {
+              const errMsg: string = `Loading monomers from '${libFileName}' error: ` +
+                `${err instanceof Error ? err.message : err.toString()}`;
+              return new MonomerLib({}, errMsg);
+            });
+          }));
+        this._monomerLib.updateLibs(libs, reload);
+      } catch (err: any) {
+        const errMsg: string = 'Loading monomer libraries error: ' +
+          `${err instanceof Error ? err.message : err.toString()}`;
+        grok.shell.warning(errMsg);
+
+        const errStack = err instanceof Error ? err.stack : undefined;
+        _package.logger.error(errMsg, undefined, errStack);
+      }
     });
   }
 
-  /** Reads library from file shares, handles .json and .sdf */
+  /** Reads library from file shares, handles .json and .sdf
+   * @param {string} path Path to library file
+   * @param {string} fileName Name of library file
+   * @return {Promise<IMonomerLib>} Promise of IMonomerLib
+   */
   async readLibrary(path: string, fileName: string): Promise<IMonomerLib> {
-    let data: any[] = [];
+    let rawLibData: any[] = [];
     let file;
     let dfSdf;
     const fileSource = new DG.FileSource(path);
@@ -154,41 +191,23 @@ export class MonomerLibHelper implements IMonomerLibHelper {
       if (funcList.length === 1) {
         file = await fileSource.readAsBytes(fileName);
         dfSdf = await grok.functions.call('Chem:importSdf', {bytes: file});
-        data = createJsonMonomerLibFromSdf(dfSdf[0]);
+        rawLibData = createJsonMonomerLibFromSdf(dfSdf[0]);
       } else {
         grok.shell.warning('Chem package is not installed');
       }
     } else {
       const file = await fileSource.readAsText(fileName);
-      data = JSON.parse(file);
+      rawLibData = JSON.parse(file);
     }
 
-    const monomers: { [type: string]: { [name: string]: Monomer } } = {};
-    const types: string[] = [];
-    //group monomers by their type
-    data.forEach((monomer) => {
-      const monomerAdd: Monomer = {
-        'symbol': monomer['symbol'],
-        'name': monomer['name'],
-        'naturalAnalog': monomer['naturalAnalog'],
-        'molfile': monomer['molfile'],
-        'rgroups': monomer['rgroups'],
-        'polymerType': monomer['polymerType'],
-        'monomerType': monomer['monomerType'],
-        'data': {}
-      };
-
-      Object.keys(monomer).forEach((prop) => {
-        if (!expectedMonomerData.includes(prop))
-          monomerAdd.data[prop] = monomer[prop];
-      });
-
-      if (!types.includes(monomer['polymerType'])) {
-        monomers[monomer['polymerType']] = {};
-        types.push(monomer['polymerType']);
+    const monomers: { [polymerType: string]: { [monomerSymbol: string]: Monomer } } = {};
+    const polymerTypes: string[] = [];
+    rawLibData.forEach((monomer) => {
+      if (!polymerTypes.includes(monomer[REQ.POLYMER_TYPE])) {
+        monomers[monomer[REQ.POLYMER_TYPE]] = {};
+        polymerTypes.push(monomer[REQ.POLYMER_TYPE]);
       }
-
-      monomers[monomer['polymerType']][monomer['symbol']] = monomerAdd;
+      monomers[monomer[REQ.POLYMER_TYPE]][monomer[REQ.SYMBOL]] = monomer as Monomer;
     });
 
     return new MonomerLib(monomers);

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

@@ -11,6 +11,7 @@ import {_package} from '../package';
 import {multipleSequenceAlginmentUIOptions} from './types';
 import {kalignVersion, msaDefaultOptions} from './constants';
 import '../../css/msa.css';
+import {ColumnInputOptions} from '@datagrok-libraries/utils/src/type-declarations';
 export class MsaWarning extends Error {
   constructor(message: string, options?: ErrorOptions) {
     super(message, options);
@@ -18,7 +19,7 @@ export class MsaWarning extends Error {
 }
 
 export async function multipleSequenceAlignmentUI(
-  options: multipleSequenceAlginmentUIOptions = {}
+  options: multipleSequenceAlginmentUIOptions = {},
 ): Promise<DG.Column> {
   return new Promise(async (resolve, reject) => {
     options.clustersCol ??= null;
@@ -50,18 +51,27 @@ export async function multipleSequenceAlignmentUI(
     const gapExtendInput = ui.floatInput('Gap extend', options.pepsea.gapExtend);
     gapExtendInput.setTooltip('Gap extension penalty to skip the alignment');
 
+    const msaParamsDiv = ui.inputs([gapOpenInput, gapExtendInput, terminalGapInput]);
+    const msaParamsButton = ui.button('Alignment parameters', () => {
+      msaParamsDiv.hidden = !msaParamsDiv.hidden;
+    }, 'Adjust alignment parameters such as penalties for opening and extending gaps');
+    msaParamsButton.classList.add('msa-params-button');
+    msaParamsDiv.hidden = true;
+    msaParamsButton.prepend(ui.icons.settings(() => null));
     const pepseaInputRootStyles: CSSStyleDeclaration[] = [methodInput.root.style];
     const kalignInputRootStyles: CSSStyleDeclaration[] = [terminalGapInput.root.style, kalignVersionDiv.style];
 
-    let performAlignment: (() => Promise<DG.Column<string>>) | undefined;
+    let performAlignment: (() => Promise<DG.Column<string> | null>) | undefined;
 
-    // TODO: allow only macromolecule colums to be chosen
+    //TODO: remove when the new version of datagrok-api is available
+    //TODO: allow only macromolecule colums to be chosen
     const colInput = ui.columnInput('Sequence', table, seqCol, async () => {
       performAlignment = await onColInputChange(
         colInput.value, table, pepseaInputRootStyles, kalignInputRootStyles,
-        methodInput, clustersColInput, gapOpenInput, gapExtendInput, terminalGapInput
+        methodInput, clustersColInput, gapOpenInput, gapExtendInput, terminalGapInput,
       );
-    }
+      //@ts-ignore
+    }, {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.columnInput('Clusters', table, options.clustersCol);
@@ -71,19 +81,18 @@ export async function multipleSequenceAlignmentUI(
     if (options.col) {
       performAlignment = await onColInputChange(
         options.col, table, pepseaInputRootStyles, kalignInputRootStyles,
-        methodInput, clustersColInput, gapOpenInput, gapExtendInput, terminalGapInput
+        methodInput, clustersColInput, gapOpenInput, gapExtendInput, terminalGapInput,
       );
 
       await onDialogOk(colInput, table, performAlignment, resolve, reject);
       return;
     }
-    const dlg = ui.dialog('MSA')
+    const _dlg = ui.dialog('MSA')
       .add(colInput)
       .add(clustersColInput)
       .add(methodInput)
-      .add(gapOpenInput)
-      .add(gapExtendInput)
-      .add(terminalGapInput)
+      .add(msaParamsDiv)
+      .add(msaParamsButton)
       .add(kalignVersionDiv)
       .onOK(async () => { await onDialogOk(colInput, table, performAlignment, resolve, reject); })
       .show();
@@ -93,9 +102,9 @@ export async function multipleSequenceAlignmentUI(
 async function onDialogOk(
   colInput: DG.InputBase< DG.Column<any>>,
   table: DG.DataFrame,
-  performAlignment: (() => Promise<DG.Column<string>>) | undefined,
+  performAlignment: (() => Promise<DG.Column<string> | null>) | undefined,
   resolve: (value: DG.Column<any>) => void,
-  reject: (reason: any) => void
+  reject: (reason: any) => void,
 ): Promise<void> {
   let msaCol: DG.Column<string> | null = null;
   const pi = DG.TaskBarProgressIndicator.create('Analyze for MSA ...');
@@ -107,7 +116,7 @@ async function onDialogOk(
       throw new Error('Invalid column format');
     msaCol = await performAlignment(); // progress
     if (msaCol == null)
-      return grok.shell.warning('Wrong column format');
+      return reject('PepSeA container has not started');
 
     table.columns.add(msaCol);
     await grok.data.detectSemanticTypes(table);
@@ -128,8 +137,8 @@ async function onColInputChange(
   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>,
-  terminalGapInput: DG.InputBase<number | null>
-): Promise<(() => Promise<DG.Column<string>>) | undefined> {
+  terminalGapInput: DG.InputBase<number | null>,
+): Promise<(() => Promise<DG.Column<string> | null>) | undefined> {
   try {
     if (col.semType !== DG.SEMTYPE.MACROMOLECULE)
       return;
@@ -150,25 +159,30 @@ async function onColInputChange(
       [NOTATION.HELM], [], false)
     ) { // PepSeA branch - Helm notation or separator notation with unknown alphabets
       switchDialog(pepseaInputRootStyles, kalignInputRootStyles, 'pepsea');
-      gapOpenInput.value = msaDefaultOptions.pepsea.gapOpen;
-      gapExtendInput.value = msaDefaultOptions.pepsea.gapExtend;
+      gapOpenInput.value ??= msaDefaultOptions.pepsea.gapOpen;
+      gapExtendInput.value ??= msaDefaultOptions.pepsea.gapExtend;
 
       return async () => await runPepsea(col, unusedName, methodInput.value!,
           gapOpenInput.value!, gapExtendInput.value!, clustersColInput.value);
     } else if (checkInputColumnUI(col, col.name, [NOTATION.SEPARATOR], [ALPHABET.UN], false)) {
       //if the column is separator with unknown alphabet, it might be helm. check if it can be converted to helm
       const potentialColNC = new NotationConverter(col);
-      if (!await potentialColNC.checkHelmCompatibility())
+      if (!await potentialColNC.checkHelmCompatibility()) {
+        switchDialog(pepseaInputRootStyles, kalignInputRootStyles, 'pepsea');
         return;
+      }
       const helmCol = potentialColNC.convert(NOTATION.HELM);
       switchDialog(pepseaInputRootStyles, kalignInputRootStyles, 'pepsea');
-      gapOpenInput.value = msaDefaultOptions.pepsea.gapOpen;
-      gapExtendInput.value = msaDefaultOptions.pepsea.gapExtend;
+      gapOpenInput.value ??= msaDefaultOptions.pepsea.gapOpen;
+      gapExtendInput.value ??= msaDefaultOptions.pepsea.gapExtend;
       // convert to helm and assign alignment function to PepSea
 
       return async () => await runPepsea(helmCol, unusedName, methodInput.value!,
             gapOpenInput.value!, gapExtendInput.value!, clustersColInput.value);
     } else {
+      gapOpenInput.value = null;
+      gapExtendInput.value = null;
+      terminalGapInput.value = null;
       switchDialog(pepseaInputRootStyles, kalignInputRootStyles, 'kalign');
       return;
     }
@@ -182,7 +196,7 @@ async function onColInputChange(
 type MSADialogType = 'kalign' | 'pepsea';
 
 function switchDialog(
-  pepseaInputRootStyles: CSSStyleDeclaration[], kalignInputRootStyles: CSSStyleDeclaration[], dialogType: MSADialogType
+  pepseaInputRootStyles: CSSStyleDeclaration[], kalignInputRootStyles: CSSStyleDeclaration[], dialogType: MSADialogType,
 ) {
   if (dialogType === 'kalign') {
     for (const inputRootStyle of pepseaInputRootStyles)

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

@@ -34,7 +34,7 @@ function _stringsToFasta(sequences: string[]): string {
  * @return {Promise<DG.Column>} Aligned sequences.
  */
 export async function runKalign(srcCol: DG.Column<string>, isAligned: boolean = false, unUsedName: string = '',
-  clustersCol: DG.Column | null = null, gapOpen?: number, gapExtend?: number, terminalGap?: number
+  clustersCol: DG.Column | null = null, gapOpen?: number, gapExtend?: number, terminalGap?: number,
 ): Promise<DG.Column> {
   let sequences: string[] = srcCol.toList();
 
@@ -60,7 +60,7 @@ export async function runKalign(srcCol: DG.Column<string>, isAligned: boolean =
 
   const CLI = await new Aioli([
     'base/1.0.0',
-    {tool: 'kalign', version: kalignVersion, reinit: true}
+    {tool: 'kalign', version: kalignVersion, reinit: true},
   ]);
   const tgtCol = DG.Column.string(unUsedName, sequencesLength);
 

package/src/utils/pepsea.ts

@@ -16,11 +16,25 @@ type PepseaBodyUnit = { ID: string, HELM: string };
 
 /** Gets the column containing MSA sequences produced by the 'PepSeA' tool from the {@link srcCol} column.
  * Does not add the result column to the dataframe of {@link srcCol}.
+ * @async
+ * @param {DG.Column} srcCol - The column containing the sequences to be aligned.
+ * @param {string} unUsedName - The name of the result column.
+ * @param {string} method - The method used for alignment.
+ * @param {number} gapOpen - The gap open penalty.
+ * @param {number} gapExtend - The gap extension penalty.
+ * @param {DG.Column} clustersCol - The column containing the clusters of the sequences.
  */
 export async function runPepsea(srcCol: DG.Column<string>, unUsedName: string,
   method: typeof pepseaMethods[number] = 'ginsi', gapOpen: number = 1.53, gapExtend: number = 0.0,
   clustersCol: DG.Column<string | number> | null = null,
-): Promise<DG.Column<string>> {
+): Promise<DG.Column<string> | null> {
+  const pepseaContainer = await grok.dapi.docker.dockerContainers.filter('bio').first();
+  if (pepseaContainer.status !== 'started' && pepseaContainer.status !== 'checking') {
+    grok.log.warning('PepSeA container has not started yet');
+    return null;
+  }
+
+
   const peptideCount = srcCol.length;
   clustersCol ??= DG.Column.int('Clusters', peptideCount).init(0);
   if (clustersCol.type != DG.COLUMN_TYPE.STRING)
@@ -41,14 +55,12 @@ export async function runPepsea(srcCol: DG.Column<string>, unUsedName: string,
       (bodies[clusterId] ??= []).push({ID: rowIndex.toString(), HELM: helmSeq});
   }
 
-  //@ts-ignore: this is a temporary workaround for the issue with docker containers. This will be fixed in 1.14.0
-  const pepseaContainer = await (grok.dapi.docker !== undefined ? grok.dapi.docker.dockerContainers : grok.dapi.dockerfiles).filter('bio').first();
   const alignedSequences: string[] = new Array(peptideCount);
   for (const body of bodies) { // getting aligned sequences for each cluster
     const alignedObject = await requestAlignedObjects(pepseaContainer.id, body, method, gapOpen, gapExtend);
     const alignments = alignedObject.Alignment;
 
-    for (const alignment of alignments) {  // filling alignedSequencesCol
+    for (const alignment of alignments) { // filling alignedSequencesCol
       alignedSequences[parseInt(alignment.ID)] = Object.entries(alignment)
         .filter((v) => !alignmentObjectMetaKeys.includes(v[0]))
         .map((v) => v[1] !== '-' ? v[1] : '')
@@ -75,8 +87,6 @@ async function requestAlignedObjects(dockerfileId: string, body: PepseaBodyUnit[
     body: JSON.stringify(body),
   };
   const path = `/align?method=${method}&gap_open=${gapOpen}&gap_extend=${gapExtend}`;
-  //@ts-ignore: this is a temporary workaround for the issue with docker containers
-  const response = await (grok.dapi.docker !== undefined ? grok.dapi.docker.dockerContainers : grok.dapi.dockerfiles)
-    .request(dockerfileId, path, params);
+  const response = await grok.dapi.docker.dockerContainers.request(dockerfileId, path, params);
   return JSON.parse(response ?? '{}');
 }

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

@@ -28,7 +28,7 @@ export function saveAsFastaUI() {
     .filter((gc: DG.GridColumn) => {
       const col: DG.Column | null = gc.column;
       if (col && col.semType === DG.SEMTYPE.MACROMOLECULE) {
-        const uh = new UnitsHandler(col);
+        const uh = UnitsHandler.getOrCreate(col);
         return uh.isFasta();
       }
       return false;
@@ -44,7 +44,7 @@ export function saveAsFastaUI() {
     .add(ui.inputs([
       idGColListInput,
       seqColInput,
-      lineWidthInput
+      lineWidthInput,
     ]))
     .onOK(() => {
       const valueIdColList: DG.Column[] = idGColListInput.value ?
@@ -66,9 +66,16 @@ export function saveAsFastaUI() {
     .show();
 }
 
-/** */
+/**
+ * Builds FASTA content from id columns list and seq column
+ * @param {DG.Column[]} idColList - list of columns with identifiers
+ * @param {DG.Column} seqCol - column with sequence
+ * @param {number} lineWidth - FASTA line width
+ * @param {string} lineSeparator - FASTA line separator
+ * @return {string} FASTA content
+ */
 export function saveAsFastaDo(
-  idColList: DG.Column[], seqCol: DG.Column, lineWidth: number = FASTA_LINE_WIDTH, lineSeparator: string = '\n'
+  idColList: DG.Column[], seqCol: DG.Column, lineWidth: number = FASTA_LINE_WIDTH, lineSeparator: string = '\n',
 ): string {
   const splitter: SplitterFunc = splitterAsFasta;
 

package/src/utils/ui-utils.ts

@@ -13,4 +13,4 @@ export function getMacromoleculeColumn(): DG.Column | any {
 export function updateDivInnerHTML(div: HTMLElement, content: string | Node): void {
   div.innerHTML = '';
   div.append(content);
-}
+}

package/src/viewers/vd-regions-viewer.ts

@@ -3,9 +3,8 @@ import * as DG from 'datagrok-api/dg';
 
 import * as rxjs from 'rxjs';
 import {WebLogoViewer, PROPS as wlPROPS} from '../viewers/web-logo-viewer';
-import {
-  VdRegionsPropsDefault, VdRegionsProps, IVdRegionsViewer,
-  VdRegion, VdRegionType
+import {IVdRegionsViewer,
+  VdRegion, VdRegionType,
 } from '@datagrok-libraries/bio/src/viewers/vd-regions';
 import {FilterSources, PositionHeight} from '@datagrok-libraries/bio/src/viewers/web-logo';
 import {Unsubscribable} from 'rxjs';
@@ -128,12 +127,12 @@ export class VdRegionsViewer extends DG.JsViewer implements IVdRegionsViewer {
 
     if (property) {
       switch (property.name) {
-      case 'regionTypes':
-        break;
-      case 'chains':
-        break;
-      case 'sequenceColumnNamePostfix':
-        break;
+        case 'regionTypes':
+          break;
+        case 'chains':
+          break;
+        case 'sequenceColumnNamePostfix':
+          break;
         // for (let orderI = 0; orderI < this.logos.length; orderI++) {
         //   for (let chainI = 0; chainI < this.chains.length; chainI++) {
         //     const chain: string = this.chains[chainI];
@@ -145,11 +144,11 @@ export class VdRegionsViewer extends DG.JsViewer implements IVdRegionsViewer {
     }
 
     switch (property.name) {
-    case 'skipEmptyPositions':
-    case 'positionWidth':
-    case 'positionHeight':
-      this.setData(this.dataFrame, this.regions); // onPropertyChanged
-      break;
+      case 'skipEmptyPositions':
+      case 'positionWidth':
+      case 'positionHeight':
+        this.setData(this.dataFrame, this.regions); // onPropertyChanged
+        break;
     }
   }
 
@@ -259,7 +258,7 @@ export class VdRegionsViewer extends DG.JsViewer implements IVdRegionsViewer {
               width: '16px',
               marginTop: '24px',
               marginLeft: '6px',
-            }
+            },
           })] : []),
           // List with controls for regions
           ...[...Array(orderList.length).keys()].map((orderI) => {
@@ -271,7 +270,7 @@ export class VdRegionsViewer extends DG.JsViewer implements IVdRegionsViewer {
                 // height: '100%',
                 marginTop: '4px',
                 marginBottom: '4px',
-              }
+              },
             });
 
             return resDiv;
@@ -280,8 +279,8 @@ export class VdRegionsViewer extends DG.JsViewer implements IVdRegionsViewer {
       },
       ['', ...[...Array(orderList.length).keys()].map(
         (orderI: number) => regionsFiltered.find(
-          (r: VdRegion) => r.order == orderList[orderI] && r.chain == this.chains[0]
-        )!.name || 'Name')]
+          (r: VdRegion) => r.order == orderList[orderI] && r.chain == this.chains[0],
+        )!.name || 'Name')],
     );
     this.mainLayout.className = 'mlb-vd-regions-viewer-table2';
     // this.mainLayout.style.background = '#EEEEFF';
@@ -294,7 +293,7 @@ export class VdRegionsViewer extends DG.JsViewer implements IVdRegionsViewer {
     this.filterSourceInput.root.style.top = '-3px';
     ui.tooltip.bind(this.filterSourceInput.root, 'Check to filter sequences for selected VRs');
 
-    const color: string = `#ffbb${Math.ceil(Math.random() * 255).toString(16)}`;
+    const _color: string = `#ffbb${Math.ceil(Math.random() * 255).toString(16)}`;
     this.host = ui.div([this.mainLayout, this.filterSourceInput!.root],
       {/*style: {backgroundColor: color}*/});
     this.root.appendChild(this.host);
@@ -310,7 +309,7 @@ export class VdRegionsViewer extends DG.JsViewer implements IVdRegionsViewer {
 
     const maxHeight: number = Math.min(logoHeight,
       Math.max(...this.logos.map((wlDict) =>
-        Math.max(...Object.values(wlDict).map((wl) => wl.maxHeight))))
+        Math.max(...Object.values(wlDict).map((wl) => wl.maxHeight)))),
     );
 
     for (let orderI = 0; orderI < this.logos.length; orderI++) {
@@ -323,11 +322,11 @@ export class VdRegionsViewer extends DG.JsViewer implements IVdRegionsViewer {
 
   // -- Handle events --
 
-  private rootOnSizeChanged(args: any): void {
+  private rootOnSizeChanged(_args: any): void {
     this.calcSize();
   }
 
-  private rootOnMouseMove(e: MouseEvent) {
+  private rootOnMouseMove(_e: MouseEvent) {
     // ui.tooltip.show('text', e.x + 8, e.y + 8,);
     // console.log(`onMouseMoveRoot.( x: ${e.x}, y: ${e.y} )`);
   }