@datagrok/bio 2.12.17 → 2.12.18

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

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',