@datagrok/bio 2.12.17 → 2.12.19

package/src/utils/monomer-lib/library-file-manager/ui.ts

@@ -4,16 +4,15 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import $ from 'cash-dom';
-import * as rxjs from 'rxjs';
+import {Subject} from 'rxjs';
 import './style.css';
 
 import {
   getUserLibSettings, setUserLibSettings
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
-import {MonomerLibManager} from '../lib-manager';
+import {getMonomerLibHelper, IMonomerLibFileManager} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 
-import {MonomerLibFileManager} from './file-manager';
 import {MonomerLibFileEventManager} from './event-manager';
 
 export async function showManageLibrariesDialog(): Promise<void> {
@@ -30,37 +29,39 @@ export async function getMonomerLibraryManagerLink(): Promise<DG.Widget> {
 }
 
 class MonomerLibraryManagerWidget {
-  private constructor(
-    private eventManager: MonomerLibFileEventManager
-  ) { }
+  private _fileManager: IMonomerLibFileManager;
 
-  private static _instance: MonomerLibraryManagerWidget;
+  private _widget: DG.Widget;
+  public get widget(): DG.Widget { return this._widget; }
 
-  static async getContent(eventManager: MonomerLibFileEventManager): Promise<DG.Widget> {
-    if (!MonomerLibraryManagerWidget._instance)
-      MonomerLibraryManagerWidget._instance = new MonomerLibraryManagerWidget(eventManager);
+  private constructor() {}
 
-    if (!MonomerLibraryManagerWidget._instance.widget)
-      MonomerLibraryManagerWidget._instance.widget = await MonomerLibraryManagerWidget._instance.createWidget();
+  private static instancePromise?: Promise<MonomerLibraryManagerWidget>;
 
-    return MonomerLibraryManagerWidget._instance.widget;
+  static async getInstance(): Promise<MonomerLibraryManagerWidget> {
+    if (MonomerLibraryManagerWidget.instancePromise === undefined) {
+      MonomerLibraryManagerWidget.instancePromise = (async () => {
+        const instance = new MonomerLibraryManagerWidget();
+        const libHelper = await getMonomerLibHelper();
+        instance._fileManager = await libHelper.getFileManager();
+        instance._widget = await instance.createWidget();
+        return instance;
+      })();
+    }
+    return MonomerLibraryManagerWidget.instancePromise;
   }
 
-  private monomerLibFileManager: MonomerLibFileManager;
-  private widget: DG.Widget | undefined;
-
   private async createWidget() {
-    this.monomerLibFileManager = await MonomerLibFileManager.getInstance(this.eventManager);
     const content = await this.getWidgetContent();
-    this.eventManager.addLibraryFileRequested$.subscribe(
+    const monomerLibHelper = await getMonomerLibHelper();
+    monomerLibHelper.eventManager.addLibraryFileRequested$.subscribe(
       async () => await this.promptToAddLibraryFiles()
     );
     return new DG.Widget(content);
   }
 
   private async getWidgetContent(): Promise<HTMLElement> {
-    this.monomerLibFileManager = await MonomerLibFileManager.getInstance(this.eventManager);
-    const libControlsForm = await LibraryControlsManager.createControlsForm(this.eventManager);
+    const libControlsForm = await LibraryControlsManager.createControlsForm();
     $(libControlsForm).addClass('monomer-lib-controls-form');
     const widgetContent = ui.divV([libControlsForm]);
     return widgetContent;
@@ -74,7 +75,7 @@ class MonomerLibraryManagerWidget {
         const name = selectedFile.name;
         const progressIndicator = DG.TaskBarProgressIndicator.create(`Adding ${name} as a monomer library`);
         try {
-          await this.monomerLibFileManager.addLibraryFile(content, name);
+          await this._fileManager.addLibraryFile(content, name);
           // this.eventManager.updateLibrarySelectionStatus(name, true);
         } catch (e) {
           grok.shell.error(`File ${name} is not a valid monomer library, verify it is aligned to HELM JSON schema.`);
@@ -87,27 +88,30 @@ class MonomerLibraryManagerWidget {
 }
 
 class LibraryControlsManager {
-  private constructor(private eventManager: MonomerLibFileEventManager) {
-    this.eventManager.updateUIControlsRequested$.subscribe(
-      async () => await this.updateControlsForm()
-    );
-    this.eventManager.librarySelectionRequested$.subscribe(
-      async ([fileName, isSelected]) => await this.updateLibrarySelectionStatus(isSelected, fileName)
-    );
+  private constructor(
+    private fileManager: IMonomerLibFileManager
+  ) {
+    this.fileManager.eventManager.updateUIControlsRequested$.subscribe(() => {
+      this.updateControlsForm();
+    });
+    this.fileManager.eventManager.librarySelectionRequested$.subscribe(async ([fileName, isSelected]) => {
+      await this.updateLibrarySelectionStatus(isSelected, fileName);
+    });
   }
-  private monomerLibFileManager: MonomerLibFileManager;
+
   private userLibSettings: UserLibSettings;
 
-  static async createControlsForm(eventManager: MonomerLibFileEventManager): Promise<HTMLElement> {
-    const manager = new LibraryControlsManager(eventManager);
+  static async createControlsForm(): Promise<HTMLElement> {
+    const libHelper = await getMonomerLibHelper();
+    const fileManager = await libHelper.getFileManager();
+    const manager = new LibraryControlsManager(fileManager);
     await manager.initialize();
 
-    return await manager._createControlsForm();
+    return manager._createControlsForm();
   }
 
-  private async _createControlsForm(): Promise<HTMLElement> {
-    this.monomerLibFileManager = await MonomerLibFileManager.getInstance(this.eventManager);
-    const libraryControls = await this.createLibraryControls();
+  private _createControlsForm(): HTMLElement {
+    const libraryControls = this.createLibraryControls();
     const inputsForm = ui.form(libraryControls);
     $(inputsForm).addClass('monomer-lib-controls-form');
 
@@ -118,14 +122,13 @@ class LibraryControlsManager {
     this.userLibSettings = await getUserLibSettings();
   };
 
-  private async updateControlsForm(): Promise<void> {
-    const updatedForm = await this._createControlsForm();
+  private updateControlsForm(): void {
+    const updatedForm = this._createControlsForm();
     $('.monomer-lib-controls-form').replaceWith(updatedForm);
   }
 
-  private async createLibraryControls(): Promise<DG.InputBase<boolean | null>[]> {
-    const fileManager = await MonomerLibFileManager.getInstance(this.eventManager);
-    const libFileNameList: string[] = fileManager.getValidLibraryPaths();
+  private createLibraryControls(): DG.InputBase<boolean | null>[] {
+    const libFileNameList: string[] = this.fileManager.getValidLibraryPaths();
     return libFileNameList.map((libFileName) => this.createLibInput(libFileName));
   }
 
@@ -134,8 +137,9 @@ class LibraryControlsManager {
     const libInput = ui.boolInput(
       libFileName,
       isMonomerLibrarySelected,
-      (isSelected: boolean) => this.eventManager.updateLibrarySelectionStatus(libFileName, isSelected)
-    );
+      (isSelected: boolean) => {
+        this.fileManager.eventManager.updateLibrarySelectionStatus(libFileName, isSelected);
+      });
     ui.tooltip.bind(libInput.root, `Include monomers from ${libFileName}`);
     const deleteIcon = ui.iconFA('trash-alt', () => this.promptForLibraryDeletion(libFileName));
     ui.tooltip.bind(deleteIcon, `Delete ${libFileName}`);
@@ -149,7 +153,8 @@ class LibraryControlsManager {
   ): Promise<void> {
     this.updateLibrarySettings(isMonomerLibrarySelected, libFileName);
     await setUserLibSettings(this.userLibSettings);
-    await MonomerLibManager.instance.loadLibraries(true);
+    const monomerLibHelper = await getMonomerLibHelper();
+    await monomerLibHelper.loadLibraries(true);
     grok.shell.info('Monomer library user settings saved');
   }
 
@@ -172,8 +177,8 @@ class LibraryControlsManager {
       .onOK(async () => {
         try {
           const progressIndicator = DG.TaskBarProgressIndicator.create(`Deleting ${fileName} library`);
-          this.updateLibrarySelectionStatus(false, fileName);
-          await this.monomerLibFileManager.deleteLibraryFile(fileName);
+          await this.updateLibrarySelectionStatus(false, fileName);
+          await this.fileManager.deleteLibraryFile(fileName);
           progressIndicator.close();
         } catch (e) {
           console.error(e);
@@ -189,7 +194,7 @@ class DialogWrapper {
 
   private static _instance: DialogWrapper;
   private dialog?: DG.Dialog;
-  private closeDialogSubject$ = new rxjs.Subject<void>();
+  private closeDialogSubject$ = new Subject<void>();
 
   static async showDialog(): Promise<void> {
     if (!DialogWrapper._instance) {
@@ -207,7 +212,7 @@ class DialogWrapper {
 
   private async getDialog(): Promise<DG.Dialog> {
     const eventManager = MonomerLibFileEventManager.getInstance();
-    const widget = await MonomerLibraryManagerWidget.getContent(eventManager);
+    const widget = (await MonomerLibraryManagerWidget.getInstance()).widget;
     const dialog = ui.dialog(
       {
         title: 'Manage monomer libraries',

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

@@ -1,10 +1,17 @@
 /* Do not change these import lines to match external modules in webpack configuration */
 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 {Observable, Subject} from 'rxjs';
 
-import {IMonomerLib, Monomer} from '@datagrok-libraries/bio/src/types/index';
+import {
+  IMonomerLib, Monomer, MonomerLibSummaryType, MonomerType, PolymerType, RGroup
+} from '@datagrok-libraries/bio/src/types';
+import {
+  HELM_REQUIRED_FIELD as REQ, HELM_RGROUP_FIELDS as RGP
+} from '@datagrok-libraries/bio/src/utils/const';
 import {MolfileHandler} from '@datagrok-libraries/chem-meta/src/parsing-utils/molfile-handler';
 
 import '../../../css/cell-renderer.css';
@@ -27,18 +34,57 @@ export class MonomerLib implements IMonomerLib {
     }
   }
 
-  getMonomer(polymerType: string, monomerSymbol: string): Monomer | null {
+  /** Creates missing {@link Monomer} */
+  addMissingMonomer(polymerType: PolymerType, monomerSymbol: string): Monomer {
+    let mSet = this._monomers[polymerType];
+    if (!mSet)
+      mSet = this._monomers[polymerType] = {};
+    const m = mSet[monomerSymbol] = {
+      [REQ.SYMBOL]: monomerSymbol,
+      [REQ.NAME]: monomerSymbol,
+      [REQ.MOLFILE]: '',
+      [REQ.AUTHOR]: 'MISSING',
+      [REQ.ID]: -1,
+      [REQ.RGROUPS]:
+        wu.count(1).take(9).map((i) => {
+          return {
+            /* eslint-disable no-multi-spaces */
+            // Samples                        //  PEPTIDE     RNA
+            [RGP.CAP_GROUP_SMILES]: '',       // '[*:1][H]'  '[*:1][H]'
+            [RGP.ALTERNATE_ID]: '',           // 'R1-H'      'R1-H'
+            [RGP.CAP_GROUP_NAME]: '',         // 'H'         'H'
+            [RGP.LABEL]: `R${i.toString()}`,  // 'R1'        'R1'
+            /* eslint-enable no-multi-spaces */
+          } as RGroup;
+        }).toArray(),
+      [REQ.SMILES]: '',
+      [REQ.POLYMER_TYPE]: polymerType,
+      [REQ.MONOMER_TYPE]: undefined as unknown as MonomerType, // TODO: Can we get monomerType from atom of POM
+      [REQ.CREATE_DATE]: null,
+    } as Monomer;
+    return m;
+  }
+
+  getMonomer(polymerType: PolymerType, argMonomerSymbol: string): Monomer | null {
+    // Adjust RNA's 'R' for ribose to 'r' and 'P' for phosphate to 'p' for case-sensitive monomer names.
+    // There are uppercase 'R' and 'P' at RNA samples in test data 'helm2.csv' but lowercase in HELMCoreLibrary.json
+    let monomerSymbol = argMonomerSymbol;
+    if (polymerType == 'RNA' && monomerSymbol == 'R')
+      monomerSymbol = 'r';
+    if (polymerType == 'RNA' && monomerSymbol == 'P')
+      monomerSymbol = 'p';
+
     if (polymerType in this._monomers! && monomerSymbol in this._monomers![polymerType])
       return this._monomers![polymerType][monomerSymbol];
     else
       return null;
   }
 
-  getPolymerTypes(): string[] {
-    return Object.keys(this._monomers);
+  getPolymerTypes(): PolymerType[] {
+    return Object.keys(this._monomers) as PolymerType[];
   }
 
-  getMonomerMolsByPolymerType(polymerType: string): { [monomerSymbol: string]: string } {
+  getMonomerMolsByPolymerType(polymerType: PolymerType): { [monomerSymbol: string]: string } {
     const res: { [monomerSymbol: string]: string } = {};
 
     Object.keys(this._monomers[polymerType] ?? {}).forEach((monomerSymbol) => {
@@ -48,14 +94,14 @@ export class MonomerLib implements IMonomerLib {
     return res;
   }
 
-  getMonomerSymbolsByType(polymerType: string): string[] {
+  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*/
-  getMonomerSymbolsByRGroup(rGroupNumber: number, polymerType: string, element?: string): string[] {
+  getMonomerSymbolsByRGroup(rGroupNumber: number, polymerType: PolymerType, element?: string): string[] {
     const monomerSymbols = this.getMonomerSymbolsByType(polymerType);
     let monomers = monomerSymbols.map((sym) => this.getMonomer(polymerType, sym));
     monomers = monomers.filter((el) => el !== null);
@@ -116,15 +162,38 @@ export class MonomerLib implements IMonomerLib {
     this._onChanged.next();
   }
 
+  getSummaryObj(): MonomerLibSummaryType {
+    const res: MonomerLibSummaryType = {};
+    const ptList: PolymerType[] = this.getPolymerTypes();
+    for (const pt of ptList)
+      res[pt] = this.getMonomerSymbolsByType(pt).length;
+    return res;
+  }
+
+  getSummaryDf(): DG.DataFrame {
+    const ptList = this.getPolymerTypes();
+
+    const countList: number[] = new Array<number>(ptList.length);
+    for (const [pt, i] of wu.enumerate(ptList))
+      countList[i] = this.getMonomerSymbolsByType(pt).length;
+
+    const resDf: DG.DataFrame = DG.DataFrame.fromColumns([
+      DG.Column.fromStrings('polymerType', ptList),
+      DG.Column.fromList(DG.COLUMN_TYPE.INT, 'count', countList),
+    ]);
+    return resDf;
+  }
+
+  /** @deprecated Keep for backward compatibility */
   getSummary(): string {
-    const monTypeList: string[] = this.getPolymerTypes();
+    const monTypeList: PolymerType[] = this.getPolymerTypes();
     const resStr: string = monTypeList.length == 0 ? 'empty' : monTypeList.map((monType) => {
       return `${monType} ${this.getMonomerSymbolsByType(monType).length}`;
     }).join('\n');
     return resStr;
   }
 
-  getTooltip(polymerType: string, monomerSymbol: string): HTMLElement {
+  getTooltip(polymerType: PolymerType, monomerSymbol: string): HTMLElement {
     // getTooltip(monomer: Monomer): HTMLElement;
     // getTooltip(monomerOrPolymerType: string | Monomer, symbol?: string): HTMLElement {
     //   let polymerType: string;

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

@@ -2,9 +2,10 @@ import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 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 {ColumnInputOptions} from '@datagrok-libraries/utils/src/type-declarations';
 
 import {runKalign} from './multiple-sequence-alignment';
 import {pepseaMethods, runPepsea} from './pepsea';
@@ -36,9 +37,10 @@ export async function multipleSequenceAlignmentUI(
     const table = options.col?.dataFrame ?? grok.shell.t;
     const seqCol = options.col ?? table.columns.bySemType(DG.SEMTYPE.MACROMOLECULE);
     if (seqCol == null) {
-      const errMsg = `MSAError: dataset doesn't conain any Macromolecule column`;
+      const errMsg: string = `Multiple sequence analysis requires a dataset with a macromolecule column.`;
       grok.shell.warning(errMsg);
       reject(new MsaWarning(errMsg));
+      return; // Prevents creating the MSA dialog
     }
 
     // UI for PepSea alignment
@@ -72,39 +74,50 @@ export async function multipleSequenceAlignmentUI(
 
     let performAlignment: (() => Promise<DG.Column<string> | null>) | undefined;
 
-    //TODO: remove when the new version of datagrok-api is available
-    //TODO: allow only macromolecule columns to be chosen
-    const colInput = ui.columnInput('Sequence', table, seqCol, async () => {
+    let prevSeqCol = seqCol;
+    const colInput = ui.columnInput(
+      'Sequence', table, seqCol,
+      async (valueCol: DG.Column) => {
+        if (!valueCol || valueCol.semType !== DG.SEMTYPE.MACROMOLECULE) {
+          okBtn.disabled = true;
+          await delay(0); // to
+          colInput.value = prevSeqCol as DG.Column<string>;
+          return;
+        }
+        prevSeqCol = valueCol;
+        okBtn.disabled = false;
         performAlignment = await onColInputChange(
           colInput.value, table, pepseaInputRootStyles, kalignInputRootStyles,
           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);
     clustersColInput.nullable = true;
-    colInput.fireChanged();
+
+    const dlg = ui.dialog('MSA')
+      .add(colInput)
+      .add(clustersColInput)
+      .add(methodInput)
+      .add(msaParamsDiv)
+      .add(msaParamsButton)
+      .add(kalignVersionDiv)
+      .onOK(async () => { await onDialogOk(colInput, table, performAlignment, resolve, reject); });
+    const okBtn = dlg.getButton('OK');
+
+    colInput.fireChanged(); // changes okBtn
     //if column is specified (from tests), run alignment and resolve with the result
     if (options.col) {
       performAlignment = await onColInputChange(
         options.col, table, pepseaInputRootStyles, kalignInputRootStyles,
         methodInput, clustersColInput, gapOpenInput, gapExtendInput, terminalGapInput,
       );
-
       await onDialogOk(colInput, table, performAlignment, resolve, reject);
-      return;
+      return; // Prevents show the dialog
     }
-    const _dlg = ui.dialog('MSA')
-      .add(colInput)
-      .add(clustersColInput)
-      .add(methodInput)
-      .add(msaParamsDiv)
-      .add(msaParamsButton)
-      .add(kalignVersionDiv)
-      .onOK(async () => { await onDialogOk(colInput, table, performAlignment, resolve, reject); })
-      .show();
+
+    dlg.show();
   });
 }
 

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

@@ -4,14 +4,16 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {_toAtomicLevel} from '@datagrok-libraries/bio/src/monomer-works/to-atomic-level';
-import {helm2mol} from './helm-to-molfile/utils';
 import {IMonomerLib} from '@datagrok-libraries/bio/src/types';
-import {checkInputColumnUI} from './check-input-column';
-import {getMonomerLibHelper} from '../package';
 import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
-export async function sequenceToMolfile(df: DG.DataFrame, macroMolecule: DG.Column, nonlinear: boolean): Promise<void> {
+import {helm2mol} from './helm-to-molfile/utils';
+import {checkInputColumnUI} from './check-input-column';
+
+export async function sequenceToMolfile(
+  df: DG.DataFrame, macroMolecule: DG.Column, nonlinear: boolean, monomerLib: IMonomerLib
+): Promise<void> {
   if (DG.Func.find({package: 'Chem', name: 'getRdKitModule'}).length === 0) {
     grok.shell.warning('Transformation to atomic level requires package "Chem" installed.');
     return;
@@ -20,12 +22,10 @@ export async function sequenceToMolfile(df: DG.DataFrame, macroMolecule: DG.Colu
     const seqSh = SeqHandler.forColumn(macroMolecule);
     if (!seqSh.isHelm())
       macroMolecule = seqSh.convert(NOTATION.HELM);
-    helm2mol(df, macroMolecule);
-    return;
+    return helm2mol(df, macroMolecule);
   }
   if (!checkInputColumnUI(macroMolecule, 'To Atomic Level'))
     return;
-  const monomerLib: IMonomerLib = getMonomerLibHelper().getBioLib();
   const atomicLevelRes = await _toAtomicLevel(df, macroMolecule, monomerLib);
   if (atomicLevelRes.col !== null) {
     df.columns.add(atomicLevelRes.col, true);

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

@@ -953,16 +953,26 @@ export class WebLogoViewer extends DG.JsViewer implements IWebLogoViewer {
 
       // region updatePositions
 
+      /** positionNames and positionLabel can be set up through the column's tags only */
+      const positionNamesTxt = this.seqCol.getTag(bioTAGS.positionNames);
+      const positionLabelsTxt = this.seqCol.getTag(bioTAGS.positionLabels);
+
+      // WebLogo in the column tooltip / widget is limited, speed up for long sequences
+      let splitLimit: number | undefined = undefined;
+      if (!positionNamesTxt && this.endPositionName && /\d+/.test(this.endPositionName))
+        splitLimit = Number(this.endPositionName);
+      else if (positionNamesTxt && this.endPositionName) {
+        splitLimit = positionNamesTxt.split(positionSeparator).indexOf(this.endPositionName);
+        splitLimit = splitLimit !== -1 ? splitLimit : undefined;
+      }
+
       const dfFilter = this.getFilter();
       const maxLength: number = dfFilter.trueCount === 0 ? this.seqHandler!.maxLength :
         wu.count(0).take(this.seqHandler!.length).map((rowIdx) => {
-          const mList = this.seqHandler!.getSplitted(rowIdx);
+          const mList = this.seqHandler!.getSplitted(rowIdx, splitLimit);
           return dfFilter.get(rowIdx) && !!mList ? mList.length : 0;
         }).reduce((max, l) => Math.max(max, l), 0);
 
-      /** positionNames and positionLabel can be set up through the column's tags only */
-      const positionNamesTxt = this.seqCol.getTag(bioTAGS.positionNames);
-      const positionLabelsTxt = this.seqCol.getTag(bioTAGS.positionLabels);
       this.positionNames = !!positionNamesTxt ? positionNamesTxt.split(positionSeparator).map((v) => v.trim()) :
         [...Array(maxLength).keys()].map((jPos) => `${jPos + 1}`)/* fallback if tag is not provided */;
       this.positionLabels = !!positionLabelsTxt ? positionLabelsTxt.split(positionSeparator).map((v) => v.trim()) :

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

@@ -135,9 +135,15 @@ export class HelmBioFilter extends BioFilterBase<BioFilterProps> /* implements I
   }
 
   async substructureSearch(column: DG.Column): Promise<DG.BitSet | null> {
-    await delay(10);
-    const res = await helmSubstructureSearch(this.props.substructure, column);
-    return res;
+    const logPrefix = `${this.viewerToLog()}.substructureSearch( column = <${column.name}> )`;
+    _package.logger.debug(`${logPrefix}, start`);
+    try {
+      await delay(10);
+      const res = await helmSubstructureSearch(this.props.substructure, column);
+      return res;
+    } finally {
+      _package.logger.debug(`${logPrefix}, end`);
+    }
   }
 
   // // -- IRenderer --

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

@@ -273,12 +273,12 @@ export class BioSubstructureFilter extends DG.Filter implements IRenderer {
   async awaitRendered(timeout: number = 10000): Promise<void> {
     const callLog = `awaitRendered( ${timeout} )`;
     const logPrefix = `${this.filterToLog()}.${callLog}`;
-    await delay(0);
+    await delay(10);
     await testEvent(this.onRendered, () => {
       this.logger.debug(`${logPrefix}, ` + '_onRendered event caught');
     }, () => {
       this.invalidate(callLog);
-    }, timeout, `${logPrefix} ${timeout} timeout`);
+    }, timeout, `${logPrefix} timeout`);
 
     // Rethrow stored syncer error (for test purposes)
     const viewErrors = this.filterSyncer.resetErrors();

package/webpack.config.js

@@ -43,6 +43,7 @@ module.exports = {
     'wu': 'wu',
     'scil': 'scil',
     'org': 'org',
+    // 'JSDraw2': 'JSDraw2',
   },
   output: {
     filename: '[name].js',