@datagrok/bio 2.12.16 → 2.12.18

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

@@ -5,10 +5,13 @@ import * as OCL from 'openchemlib/full';
 
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
 import {RDModule, RDMol} from '@datagrok-libraries/chem-meta/src/rdkit-api';
-import {_package} from '../../../package';
+import {IMonomerLib} from '@datagrok-libraries/bio/src/types/index';
+
 import {Polymer} from './polymer';
 import {GlobalMonomerPositionHandler} from './position-handler';
 
+import {_package, getMonomerLibHelper} from '../../../package';
+
 export class HelmToMolfileConverter {
   constructor(private helmColumn: DG.Column<string>, private df: DG.DataFrame) {
     this.helmColumn = helmColumn;
@@ -54,7 +57,7 @@ export class HelmToMolfileConverter {
   async convertToRdKitBeautifiedMolfileColumn(chiralityEngine?: boolean): Promise<DG.Column<string>> {
     const molfilesV3K = (await this.convertToMolfileV3KColumn()).toList();
     const rdKitModule: RDModule = await grok.functions.call('Chem:getRdKitModule');
-    const beautifiedMols = molfilesV3K.map((item) =>{
+    const beautifiedMols = molfilesV3K.map((item) => {
       if (item === '')
         return null;
       const mol = rdKitModule.get_mol(item);
@@ -81,6 +84,7 @@ export class HelmToMolfileConverter {
   private async convertToMolfileV3KColumn(): Promise<DG.Column<string>> {
     const polymerGraphColumn: DG.Column<string> = await this.getPolymerGraphColumn();
     const rdKitModule = await grok.functions.call('Chem:getRdKitModule');
+    const monomerLib: IMonomerLib = (await getMonomerLibHelper()).getBioLib();
     const molfileList = polymerGraphColumn.toList().map(
       (pseudoMolfile: string, idx: number) => {
         const helm = this.helmColumn.get(idx);
@@ -88,7 +92,7 @@ export class HelmToMolfileConverter {
           return '';
         let result = '';
         try {
-          result = this.getPolymerMolfile(helm, pseudoMolfile, rdKitModule);
+          result = this.getPolymerMolfile(helm, pseudoMolfile, rdKitModule, monomerLib);
         } catch (err: any) {
           const [errMsg, errStack] = errInfo(err);
           _package.logger.error(errMsg, undefined, errStack);
@@ -110,10 +114,11 @@ export class HelmToMolfileConverter {
   private getPolymerMolfile(
     helm: string,
     polymerGraph: string,
-    rdKitModule: RDModule
+    rdKitModule: RDModule,
+    monomerLib: IMonomerLib
   ): string {
     const globalPositionHandler = new GlobalMonomerPositionHandler(polymerGraph);
-    const polymer = new Polymer(helm, rdKitModule);
+    const polymer = new Polymer(helm, rdKitModule, monomerLib);
     globalPositionHandler.monomerSymbols.forEach((monomerSymbol: string, monomerIdx: number) => {
       const shift = globalPositionHandler.getMonomerShifts(monomerIdx);
       polymer.addMonomer(monomerSymbol, monomerIdx, shift);

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

@@ -1,11 +1,11 @@
-import {Monomer} from '@datagrok-libraries/bio/src/types';
+import {IMonomerLib, Monomer} from '@datagrok-libraries/bio/src/types';
 import {HELM_RGROUP_FIELDS} from '@datagrok-libraries/bio/src/utils/const';
 import {RDModule, RDMol} from '@datagrok-libraries/chem-meta/src/rdkit-api';
-import {MonomerLibManager} from '../../monomer-lib/lib-manager';
+import {MolfileHandler} from '@datagrok-libraries/chem-meta/src/parsing-utils/molfile-handler';
+
 import {Helm} from './helm';
 import {MolfileWrapper} from './mol-wrapper';
 import {MolfileWrapperFactory} from './mol-wrapper-factory';
-import {MolfileHandler} from '@datagrok-libraries/chem-meta/src/parsing-utils/molfile-handler';
 
 export class MonomerWrapper {
   private molfileWrapper: MolfileWrapper;
@@ -15,8 +15,9 @@ export class MonomerWrapper {
     private monomerSymbol: string,
     private monomerIdx: number,
     private helm: Helm,
-    shift: {x: number, y: number},
-    rdKitModule: RDModule
+    shift: { x: number, y: number },
+    rdKitModule: RDModule,
+    private readonly monomerLib: IMonomerLib
   ) {
     const libraryMonomerObject = this.getLibraryMonomerObject();
 
@@ -37,7 +38,7 @@ export class MonomerWrapper {
   private convertMolfileToV3KFormat(molfileV2K: string, monomerSymbol: string, rdKitModule: RDModule): string {
     let mol: RDMol | null = null;
     try {
-      mol = rdKitModule.get_mol(molfileV2K, JSON.stringify({mergeQueryHs: true}))
+      mol = rdKitModule.get_mol(molfileV2K, JSON.stringify({mergeQueryHs: true}));
       if (mol)
         return mol.get_v3Kmolblock();
       else
@@ -49,8 +50,7 @@ export class MonomerWrapper {
 
   private getLibraryMonomerObject(): Monomer {
     const polymerType = this.helm.getPolymerTypeByMonomerIdx(this.monomerIdx);
-    const monomerLib = MonomerLibManager.instance.getBioLib();
-    const monomer = monomerLib.getMonomer(polymerType, this.monomerSymbol);
+    const monomer = this.monomerLib.getMonomer(polymerType, this.monomerSymbol);
     if (!monomer)
       throw new Error(`Monomer ${this.monomerSymbol} is not found in the library`);
     return monomer;
@@ -72,7 +72,7 @@ export class MonomerWrapper {
     return result;
   }
 
-  private shiftCoordinates(shift: {x: number, y: number}): void {
+  private shiftCoordinates(shift: { x: number, y: number }): void {
     this.molfileWrapper.shiftCoordinates(shift);
   }
 

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

@@ -1,10 +1,16 @@
 import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
 import {V3K_CONST} from '@datagrok-libraries/chem-meta/src/formats/molfile-const';
+import {IMonomerLib} from '@datagrok-libraries/bio/src/types/index';
+
 import {Helm} from './helm';
 import {MonomerWrapper} from './monomer-wrapper';
 
 export class Polymer {
-  constructor(helmString: string, private rdKitModule: RDModule) {
+  constructor(
+    helmString: string,
+    private readonly rdKitModule: RDModule,
+    private readonly monomerLib: IMonomerLib
+  ) {
     this.helm = new Helm(helmString);
   }
 
@@ -14,9 +20,10 @@ export class Polymer {
   addMonomer(
     monomerSymbol: string,
     monomerIdx: number,
-    shift: {x: number, y: number},
+    shift: { x: number, y: number },
   ): void {
-    const monomerWrapper = new MonomerWrapper(monomerSymbol, monomerIdx, this.helm, shift, this.rdKitModule);
+    const monomerWrapper = new MonomerWrapper(
+      monomerSymbol, monomerIdx, this.helm, shift, this.rdKitModule, this.monomerLib);
 
     this.monomerWrappers.push(monomerWrapper);
   }

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

@@ -5,9 +5,10 @@ import * as ui from 'datagrok-api/ui';
 import {ALPHABET, getPaletteByType, monomerToShort} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
 import {MonomerWorks} from '@datagrok-libraries/bio/src/monomer-works/monomer-works';
+import {PolymerType} from '@datagrok-libraries/bio/src/types';
 
-import {getMonomerLibHelper} from '../package';
 import * as C from './constants';
+import {getMonomerLib} from '../package';
 
 const Tags = new class {
   tooltipHandlerTemp = 'tooltip-handler.Monomer';
@@ -29,20 +30,29 @@ export class MonomerTooltipHandler {
       !gridCell.tableColumn || !gridCell.isTableCell
     ) return false;
 
-    const alphabet = gridCell.tableColumn.getTag(bioTAGS.alphabet);
+    const alphabet = gridCell.tableColumn.getTag(bioTAGS.alphabet) as ALPHABET;
     const monomerName = gridCell.cell.value;
-    const mw = new MonomerWorks(getMonomerLibHelper().getBioLib());
-    const monomerType: string = (alphabet === ALPHABET.DNA || alphabet === ALPHABET.RNA) ? 'RNA' :
+    const canvasClientRect = gridCell.grid.canvas.getBoundingClientRect();
+    const x1 = gridCell.bounds.right + canvasClientRect.left - 4;
+    const y1 = gridCell.bounds.bottom + canvasClientRect.top - 4;
+
+    const monomerLib = getMonomerLib();
+    if (!monomerLib) {
+      ui.tooltip.show(ui.divText('Monomer library is not available.'), x1, y1);
+      return true;
+    }
+
+    const mw = new MonomerWorks(monomerLib);
+    const polymerType: PolymerType = (alphabet === ALPHABET.DNA || alphabet === ALPHABET.RNA) ? 'RNA' :
       alphabet === ALPHABET.PT ? 'PEPTIDE' : 'PEPTIDE';
+    // const biotype: HelmType = [ALPHABET.RNA, ALPHABET.DNA].includes(alphabet) ? HelmTypes.NUCLEOTIDE :
+    //   [ALPHABET.PT].includes(alphabet) ? HelmTypes.AA : HelmTypes.AA;
 
-    const monomerMol: string | null = mw.getCappedRotatedMonomer(monomerType, monomerName);
+    const monomerMol: string | null = mw.getCappedRotatedMonomer(polymerType, monomerName);
     const nameDiv = ui.div(monomerName);
     const molDiv = !monomerMol ? null :
       grok.chem.svgMol(monomerMol, undefined, undefined, svgMolOptions);
 
-    const canvasClientRect = gridCell.grid.canvas.getBoundingClientRect();
-    const x1 = gridCell.bounds.right + canvasClientRect.left - 4;
-    const y1 = gridCell.bounds.bottom + canvasClientRect.top - 4;
     ui.tooltip.show(ui.divV([nameDiv, ...(molDiv ? [molDiv] : [])]), x1, y1);
 
     return true; // To prevent default tooltip behaviour

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

@@ -3,33 +3,51 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {IMonomerLib} from '@datagrok-libraries/bio/src/types/index';
+import {delay} from '@datagrok-libraries/utils/src/test';
+import {IMonomerLib} from '@datagrok-libraries/bio/src/types';
 import {
   getUserLibSettings, setUserLibSettings, LIB_PATH
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 import {
-  IMonomerLibHelper,
+  IMonomerLibFileEventManager, IMonomerLibHelper,
 } from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+
 import {MonomerLib} from './monomer-lib';
 import {MonomerLibFileManager} from './library-file-manager/file-manager';
 import {MonomerLibFileEventManager} from './library-file-manager/event-manager';
+
 import {_package} from '../../package';
 
-type MonomerLibWindowType = Window & { $monomerLibHelper: MonomerLibManager };
+type MonomerLibWindowType = Window & { $monomerLibHelperPromise?: Promise<MonomerLibManager> };
 declare const window: MonomerLibWindowType;
 
-export async function getLibFileNameList(): Promise<string[]> {
-  const fileEventManager = MonomerLibFileEventManager.getInstance();
-  const fileManager = await MonomerLibFileManager.getInstance(fileEventManager);
-  return fileManager.getValidLibraryPaths();
-}
-
 /** Singleton wrapper for MonomerLib, provides API for managing libraries on
  * the platform  */
 export class MonomerLibManager implements IMonomerLibHelper {
   private readonly _monomerLib = new MonomerLib({}, 'MAIN');
 
+  private _eventManager: MonomerLibFileEventManager;
+
+  public get eventManager(): IMonomerLibFileEventManager { return this._eventManager; }
+
+  public async awaitLoaded(timeout: number = 3000): Promise<void> {
+    return await Promise.race([
+      (async () => {
+        const fileManager = await this.getFileManager();
+        await fileManager.filesPromise;
+        return true;
+      })(),
+      (async () => {
+        await delay(timeout);
+        return false;
+      })(),
+    ]).then((res) => {
+      if (!res)
+        throw new Error(`Loading monomer libraries is timeout ${timeout} ms.`);
+    });
+  }
+
   /** Protect constructor to prevent multiple instantiation. */
   protected constructor() {}
 
@@ -40,6 +58,19 @@ export class MonomerLibManager implements IMonomerLibHelper {
     return this._monomerLib;
   }
 
+  /** Instance promise of {@link getFileManager} */
+  private _fileManagerPromise?: Promise<MonomerLibFileManager>;
+
+  async getFileManager(): Promise<MonomerLibFileManager> {
+    if (this._fileManagerPromise === undefined) {
+      this._fileManagerPromise = (async () => {
+        const fileManager: MonomerLibFileManager = await MonomerLibFileManager.create(this, this._eventManager);
+        return fileManager;
+      })();
+    }
+    return this._fileManagerPromise;
+  }
+
   /** Allows syncing with managing settings/loading libraries */
   public loadLibrariesPromise: Promise<void> = Promise.resolve();
 
@@ -53,7 +84,7 @@ export class MonomerLibManager implements IMonomerLibHelper {
       // through blocking this.loadLibrariesPromise
       try {
         const [libFileNameList, settings]: [string[], UserLibSettings] = await Promise.all([
-          getLibFileNameList(),
+          (await this.getFileManager()).getValidLibraryPaths(),
           getUserLibSettings(),
         ]);
 
@@ -91,9 +122,8 @@ export class MonomerLibManager implements IMonomerLibHelper {
    * @return {Promise<IMonomerLib>} Promise of IMonomerLib
    */
   async readLibrary(path: string, fileName: string): Promise<IMonomerLib> {
-    const eventManager = MonomerLibFileEventManager.getInstance();
-    const libFileManager = await MonomerLibFileManager.getInstance(eventManager);
-    const lib: IMonomerLib = await libFileManager.loadLibraryFromFile(path, fileName);
+    const fileManager = await this.getFileManager();
+    const lib: IMonomerLib = await fileManager.loadLibraryFromFile(path, fileName);
     return lib;
   }
 
@@ -103,19 +133,27 @@ export class MonomerLibManager implements IMonomerLibHelper {
     if (invalidNames.length > 0)
       throw new Error(`Cannot select libraries ${invalidNames}: no such library in the list`);
     const settings = await getUserLibSettings();
-    settings.exclude = (await getLibFileNameList()).filter((fileName) => !libFileNameList.includes(fileName));
+    settings.exclude = ((await this.getFileManager()).getValidLibraryPaths())
+      .filter((fileName) => !libFileNameList.includes(fileName));
     await setUserLibSettings(settings);
   }
 
   private async getInvalidFileNames(libFileNameList: string[]): Promise<string[]> {
-    const availableFileNames = await getLibFileNameList();
+    const availableFileNames = (await this.getFileManager()).getValidLibraryPaths();
     const invalidNames = libFileNameList.filter((fileName) => !availableFileNames.includes(fileName));
     return invalidNames;
   }
 
   // -- Instance singleton --
-  public static get instance(): MonomerLibManager {
-    if (!window.$monomerLibHelper) window.$monomerLibHelper = new MonomerLibManager();
-    return window.$monomerLibHelper;
+  public static async getInstance(): Promise<MonomerLibManager> {
+    let res = window.$monomerLibHelperPromise;
+    if (res === undefined) {
+      res = window.$monomerLibHelperPromise = (async () => {
+        const instance = new MonomerLibManager();
+        instance._eventManager = MonomerLibFileEventManager.getInstance();
+        return instance;
+      })();
+    }
+    return res;
   }
 }

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

@@ -1,7 +1,13 @@
-import * as rxjs from 'rxjs';
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {BehaviorSubject, Observable, Subject} from 'rxjs';
 import {debounceTime, tap, skip} from 'rxjs/operators';
 
-export class MonomerLibFileEventManager {
+import {IMonomerLibFileEventManager} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+
+export class MonomerLibFileEventManager implements IMonomerLibFileEventManager {
   // WARNING: this must be a singleton because it manages the unique state
   private constructor() {}
 
@@ -14,9 +20,9 @@ export class MonomerLibFileEventManager {
     return MonomerLibFileEventManager._instance;
   }
 
-  private _libraryFilesUpdateSubject$ = new rxjs.BehaviorSubject<string[]>([]);
-  private _addLibraryFilesSubject$ = new rxjs.Subject<void>();
-  private _librarySelectionSubject$ = new rxjs.Subject<[string, boolean]>();
+  private _libraryFilesUpdateSubject$ = new BehaviorSubject<string[]>([]);
+  private _addLibraryFilesSubject$ = new Subject<void>();
+  private _librarySelectionSubject$ = new Subject<[string, boolean]>();
 
   getValidFilesPathList(): string[] {
     return this._libraryFilesUpdateSubject$.getValue();
@@ -38,19 +44,19 @@ export class MonomerLibFileEventManager {
     this._libraryFilesUpdateSubject$.next(newList);
   }
 
-  get updateUIControlsRequested$(): rxjs.Observable<string[]> {
+  get updateUIControlsRequested$(): Observable<string[]> {
     return this._libraryFilesUpdateSubject$.pipe(
       // debounceTime(1000)
     );
   }
 
-  get updateValidLibraryFileListRequested$(): rxjs.Observable<string[]> {
+  get updateValidLibraryFileListRequested$(): Observable<string[]> {
     return this._libraryFilesUpdateSubject$.pipe(
       // debounceTime(3000)
     );
   }
 
-  get addLibraryFileRequested$(): rxjs.Observable<void> {
+  get addLibraryFileRequested$(): Observable<void> {
     return this._addLibraryFilesSubject$.pipe(
       // debounceTime(1000)
     );
@@ -60,7 +66,7 @@ export class MonomerLibFileEventManager {
     this._addLibraryFilesSubject$.next();
   }
 
-  get librarySelectionRequested$(): rxjs.Observable<[string, boolean]> {
+  get librarySelectionRequested$(): Observable<[string, boolean]> {
     return this._librarySelectionSubject$;
   }
 

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

@@ -3,47 +3,56 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {IMonomerLib, Monomer} from '@datagrok-libraries/bio/src/types/index';
+import {JSONSchemaType} from 'ajv';
+
+import {IMonomerLib, Monomer} from '@datagrok-libraries/bio/src/types';
 import {LIB_PATH} from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
-import {MonomerLib} from '../monomer-lib';
 import {
   HELM_REQUIRED_FIELD as REQ,
 } from '@datagrok-libraries/bio/src/utils/const';
-import {JSONSchemaType} from 'ajv';
+import {
+  IMonomerLibHelper, IMonomerLibFileManager
+} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+
+import {MonomerLib} from '../monomer-lib';
 import {HELM_JSON_SCHEMA_PATH} from './consts';
 import {MonomerLibFileEventManager} from './event-manager';
-
 import {MonomerLibFileValidator} from './file-validator';
-import {MonomerLibManager} from '../lib-manager';
+
+import {_package} from '../../../package';
+
 
 /** Singleton for adding, validation and reading of monomer library files.
  * All files **must** be aligned to the HELM standard before adding. */
-export class MonomerLibFileManager {
+export class MonomerLibFileManager implements IMonomerLibFileManager {
+  public filesPromise: Promise<void> = Promise.resolve();
+
   private constructor(
-    private libraryFileValidator: MonomerLibFileValidator,
-    private libraryEventManager: MonomerLibFileEventManager,
+    private readonly fileValidator: MonomerLibFileValidator,
+    private readonly libHelper: IMonomerLibHelper,
+    public readonly eventManager: MonomerLibFileEventManager,
   ) {
-    this.libraryEventManager.updateValidLibraryFileListRequested$.subscribe(async () => {
+    this.eventManager.updateValidLibraryFileListRequested$.subscribe(async () => {
       await this.updateValidLibraryList();
     });
   }
 
-  private static instancePromise: Promise<MonomerLibFileManager> | undefined;
+  private static objCounter: number = -1;
+  private readonly objId: number = ++MonomerLibFileManager.objCounter;
+
+  protected toLog(): string {
+    return `MonomerLibFileManager<${this.objId}>`;
+  }
 
-  static async getInstance(
-    libraryEventManager: MonomerLibFileEventManager,
+  /** For internal use only, get {@link IMonomerLibHelper.getFileManager} */
+  public static async create(
+    libHelper: IMonomerLibHelper, eventManager: MonomerLibFileEventManager
   ): Promise<MonomerLibFileManager> {
-    if (!MonomerLibFileManager.instancePromise) {
-      MonomerLibFileManager.instancePromise = (async () => {
-        const helmSchemaRaw = await grok.dapi.files.readAsText(HELM_JSON_SCHEMA_PATH);
-        const helmSchema = JSON.parse(helmSchemaRaw) as JSONSchemaType<any>;
-
-        const fileValidator = new MonomerLibFileValidator(helmSchema);
-        return new MonomerLibFileManager(fileValidator, libraryEventManager);
-      })();
-    }
+    const helmSchemaRaw = await grok.dapi.files.readAsText(HELM_JSON_SCHEMA_PATH);
+    const helmSchema = JSON.parse(helmSchemaRaw) as JSONSchemaType<any>;
 
-    return MonomerLibFileManager.instancePromise;
+    const fileValidator = new MonomerLibFileValidator(helmSchema);
+    return new MonomerLibFileManager(fileValidator, libHelper, eventManager);
   }
 
   /** Add standard .json monomer library  */
@@ -91,72 +100,82 @@ export class MonomerLibFileManager {
     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]);
+      const polymerType = monomer[REQ.POLYMER_TYPE];
+      const monomerSymbol = monomer[REQ.SYMBOL];
+      if (!polymerTypes.includes(polymerType)) {
+        monomers[polymerType] = {};
+        polymerTypes.push(polymerType);
       }
-      monomers[monomer[REQ.POLYMER_TYPE]][monomer[REQ.SYMBOL]] = monomer as Monomer;
+      monomers[polymerType][monomerSymbol] = monomer as Monomer;
     });
 
     return new MonomerLib(monomers, fileName);
   }
 
   getValidLibraryPaths(): string[] {
-    return this.libraryEventManager.getValidFilesPathList();
+    return this.eventManager.getValidFilesPathList();
   }
 
   // TODO: remove after adding init from user data storage
   // WARNING: a temporary solution
   async getValidLibraryPathsAsynchronously(): Promise<string[]> {
-    return await this.libraryEventManager.getValidLibraryPathsAsynchronously();
+    return await this.eventManager.getValidLibraryPathsAsynchronously();
   }
 
-
   private async libraryFileExists(fileName: string): Promise<boolean> {
     return await grok.dapi.files.exists(LIB_PATH + `${fileName}`);
   }
 
   private async updateValidLibraryList(): Promise<void> {
-    const invalidFiles = [] as string[];
-    // console.log(`files before validation:`, this.libraryEventManager.getValidFilesPathList());
-    const filePaths = await this.getFilePathsAtDefaultLocation();
+    const logPrefix: string = `${this.toLog()}.updateValidLibraryList()`;
+    _package.logger.debug(`${logPrefix}, start`);
+    return this.filesPromise = this.filesPromise.then(async () => {
+      _package.logger.debug(`${logPrefix}, IN`);
+      const invalidFiles = [] as string[];
+      // console.log(`files before validation:`, this.libraryEventManager.getValidFilesPathList());
+      const filePaths = await this.getFilePathsAtDefaultLocation();
+
+      if (!this.fileListHasChanged(filePaths)) {
+        _package.logger.debug(`${logPrefix}, end, not changed`);
+        return;
+      }
 
-    if (!this.fileListHasChanged(filePaths))
-      return;
+      for (const path of filePaths) {
+        if (!path.endsWith('.json')) {
+          invalidFiles.push(path);
+          continue;
+        }
 
-    for (const path of filePaths) {
-      if (!path.endsWith('.json')) {
-        invalidFiles.push(path);
-        continue;
+        const fileContent = await grok.dapi.files.readAsText(LIB_PATH + `${path}`);
+        if (!this.isValidHELMLibrary(fileContent, path))
+          invalidFiles.push(path);
       }
 
-      const fileContent = await grok.dapi.files.readAsText(LIB_PATH + `${path}`);
-      if (!this.isValidHELMLibrary(fileContent, path))
-        invalidFiles.push(path);
-    }
-
-    const validLibraryPaths = filePaths.filter((path) => !invalidFiles.includes(path));
+      const validLibraryPaths = filePaths.filter((path) => !invalidFiles.includes(path));
 
-    if (this.fileListHasChanged(validLibraryPaths)) {
-      this.libraryEventManager.changeValidFilesPathList(validLibraryPaths);
-      MonomerLibManager.instance.loadLibraries(true);
-    }
-    // console.log(`files after validation:`, this.libraryEventManager.getValidFilesPathList());
+      if (this.fileListHasChanged(validLibraryPaths)) {
+        this.eventManager.changeValidFilesPathList(validLibraryPaths);
+        this.libHelper.loadLibraries(true);
+      }
+      // console.log(`files after validation:`, this.libraryEventManager.getValidFilesPathList());
 
-    if (validLibraryPaths.some((el) => !el.endsWith('.json')))
-      console.warn(`Wrong validation: ${validLibraryPaths}`);
+      if (validLibraryPaths.some((el) => !el.endsWith('.json')))
+        _package.logger.warning(`Wrong validation: ${validLibraryPaths}`);
 
-    if (invalidFiles.length > 0) {
-      const message = `Invalid monomer library files in ${LIB_PATH}` +
-        `, consider fixing or removing them: ${invalidFiles.join(', ')}`;
+      if (invalidFiles.length > 0) {
+        const message = `Invalid monomer library files in ${LIB_PATH}` +
+          `, consider fixing or removing them: ${invalidFiles.join(', ')}`;
 
-      console.warn(message);
-      // grok.shell.warning(message);
-    }
+        _package.logger.warning(message);
+        // grok.shell.warning(message);
+      }
+      _package.logger.debug(`${logPrefix}, OUT`);
+    });
+    _package.logger.debug(`${logPrefix}, end`);
   }
 
   private fileListHasChanged(newList: string[]): boolean {
-    const currentList = this.libraryEventManager.getValidFilesPathList();
+    const currentList = this.eventManager.getValidFilesPathList();
     return newList.length !== currentList.length || newList.some((el, i) => el !== currentList[i]);
   }
 
@@ -167,7 +186,7 @@ export class MonomerLibFileManager {
   }
 
   private isValidHELMLibrary(fileContent: string, fileName: string): boolean {
-    return this.libraryFileValidator.validateFile(fileContent, fileName);
+    return this.fileValidator.validateFile(fileContent, fileName);
   }
 
   /** Get relative paths for files in LIB_PATH  */

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

@@ -5,7 +5,9 @@ import addErrors from 'ajv-errors';
 export class MonomerLibFileValidator {
   private validateMonomerSchema: ValidateFunction<any>;
 
-  constructor(private helmMonomerSchema: JSONSchemaType<any>) {
+  constructor(
+    private helmMonomerSchema: JSONSchemaType<any>
+  ) {
     const ajv = new Ajv2020({allErrors: true, strictTuples: false});
     addErrors(ajv);
     this.validateMonomerSchema = ajv.compile(this.helmMonomerSchema);