@datagrok/bio 2.11.30 → 2.11.33

package/src/package-test.ts

@@ -1,3 +1,5 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {runTests, TestContext, tests} from '@datagrok-libraries/utils/src/test';
@@ -17,6 +19,8 @@ import './tests/fasta-handler-test';
 import './tests/fasta-export-tests';
 import './tests/bio-tests';
 import './tests/WebLogo-positions-test';
+import './tests/WebLogo-project-tests';
+import './tests/WebLogo-layout-tests';
 import './tests/checkInputColumn-tests';
 import './tests/similarity-diversity-tests';
 import './tests/substructure-filters-tests';

package/src/package.ts

@@ -41,10 +41,8 @@ import {getMacromoleculeColumnPropertyPanel} from './widgets/representations';
 import {saveAsFastaUI} from './utils/save-as-fasta';
 import {BioSubstructureFilter} from './widgets/bio-substructure-filter';
 import {WebLogoViewer} from './viewers/web-logo-viewer';
-import {
-  MonomerLibHelper,
-  getLibraryPanelUI
-} from './utils/monomer-lib';
+import {MonomerLibManager} from './utils/monomer-lib/lib-manager';
+import {getMonomerLibraryManagerLink, showManageLibrariesDialog} from './utils/monomer-lib/library-file-manager/ui';
 import {demoBio01UI} from './demo/bio01-similarity-diversity';
 import {demoBio01aUI} from './demo/bio01a-hierarchical-clustering-and-sequence-space';
 import {demoBio01bUI} from './demo/bio01b-hierarchical-clustering-and-activity-cliffs';
@@ -88,7 +86,7 @@ export const _package = new BioPackage();
 //description:
 //output: object result
 export function getMonomerLibHelper(): IMonomerLibHelper {
-  return MonomerLibHelper.instance;
+  return MonomerLibManager.instance;
 }
 
 export let hydrophobPalette: SeqPaletteCustom | null = null;
@@ -110,7 +108,7 @@ export async function initBio() {
   _package.logger.debug('Bio: initBio(), started');
   const module = await grok.functions.call('Chem:getRdKitModule');
   await Promise.all([
-    (async () => { await MonomerLibHelper.instance.loadLibraries(); })(),
+    (async () => { await MonomerLibManager.instance.loadLibraries(); })(),
     (async () => {
       const pkgProps = await _package.getProperties();
       const bioPkgProps = new BioPackageProperties(pkgProps);
@@ -120,7 +118,7 @@ export async function initBio() {
     _package.completeInit();
   });
 
-  const monomerLib = MonomerLibHelper.instance.getBioLib();
+  const monomerLib = MonomerLibManager.instance.getBioLib();
   const monomers: string[] = [];
   const logPs: number[] = [];
 
@@ -163,12 +161,19 @@ export function sequenceTooltip(col: DG.Column): DG.Widget<any> {
 //name: getBioLib
 //output: object monomerLib
 export function getBioLib(): IMonomerLib {
-  return MonomerLibHelper.instance.getBioLib();
+  return MonomerLibManager.instance.getBioLib();
+}
+
+//name: getUnitsHandler
+//input: column sequence { semType: Macromolecule }
+//output: object result
+export function getUnitsHandler(sequence: DG.Column<string>): UnitsHandler {
+  return UnitsHandler.getOrCreate(sequence);
 }
 
 // -- Panels --
 
-//name: Get Region
+//name: Bioinformatics | Get Region
 //description: Creates a new column with sequences of the region between start and end
 //tags: panel
 //input: column seqCol {semType: Macromolecule}
@@ -183,13 +188,14 @@ export function getRegionPanel(seqCol: DG.Column<string>): DG.Widget {
   return funcEditor.widget();
 }
 
-//name: Manage Libraries
+//name: Bioinformatics | Manage Monomer Libraries
 //description:
 //tags: panel, exclude-actions-panel
 //input: column seqColumn {semType: Macromolecule}
 //output: widget result
 export async function libraryPanel(_seqColumn: DG.Column): Promise<DG.Widget> {
-  return getLibraryPanelUI();
+  // return getLibraryPanelUI();
+  return getMonomerLibraryManagerLink();
 }
 
 // -- Func Editors --
@@ -293,7 +299,7 @@ export function fastaSequenceCellRenderer(): MacromoleculeSequenceCellRenderer {
 
 // -- Property panels --
 
-//name: Sequence Renderer
+//name:  Bioinformatics | Sequence Renderer
 //input: column molColumn {semType: Macromolecule}
 //tags: panel
 //output: widget result
@@ -650,18 +656,6 @@ export async function compositionAnalysis(): Promise<void> {
   await handler(col);
 }
 
-// 2023-05-17 Representations does not work at BioIT
-// //name: Representations
-// //tags: panel, widgets
-// //input: cell macroMolecule {semType: Macromolecule}
-// //output: widget result
-// export async function peptideMolecule(macroMolecule: DG.Cell): Promise<DG.Widget> {
-//   const monomersLibFile = await _package.files.readAsText(HELM_CORE_LIB_FILENAME);
-//   const monomersLibObject: any[] = JSON.parse(monomersLibFile);
-//
-//   return representationsWidget(macroMolecule, monomersLibObject);
-// }
-
 //name: importFasta
 //description: Opens FASTA file
 //tags: file-handler
@@ -871,6 +865,14 @@ export async function sequenceSimilarityScoring(
   return scores;
 }
 
+
+//top-menu: Bio | Manage | Monomer Libraries
+//name: Manage Monomer Libraries
+//description: Manage HELM monomer libraries
+export async function manageMonomerLibraries(): Promise<void> {
+  showManageLibrariesDialog();
+}
+
 //name: saveAsFasta
 //description: As FASTA...
 //tags: fileExporter

package/src/tests/WebLogo-layout-tests.ts

@@ -0,0 +1,37 @@
+import * as DG from 'datagrok-api/dg';
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+
+import wu from 'wu';
+
+import {category, expect, test, testViewer} from '@datagrok-libraries/utils/src/test';
+
+import {awaitGrid} from './utils';
+import {WebLogoViewer} from '../viewers/web-logo-viewer';
+
+import {_package} from '../package-test';
+
+category('WebLogo-layout', () => {
+  test('fasta', async () => {
+    const df = await _package.files.readCsv('tests/filter_FASTA.csv');
+    const col = df.getCol('fasta');
+    await grok.data.detectSemanticTypes(df);
+    const view = grok.shell.addTableView(df);
+    const wlViewer = await df.plot.fromType('WebLogo',
+      {sequenceColumnName: col.name}) as unknown as WebLogoViewer;
+    view.dockManager.dock(wlViewer);
+    await wlViewer.awaitRendered();
+    await awaitGrid(view.grid);
+
+    const viewLayout = view.saveLayout();
+    const viewLayoutJsonStr = viewLayout.toJson();
+    view.loadLayout(viewLayout);
+    await wlViewer.awaitRendered();
+    await awaitGrid(view.grid);
+
+    const viewersA = wu(view.viewers).toArray();
+    expect(viewersA.length, 2 /* Grid and WebLogo */);
+    expect(viewersA.filter((f) => f.type === 'Grid').length, 1);
+    expect(viewersA.filter((f) => f.type === 'WebLogo').length, 1);
+  });
+});

package/src/tests/WebLogo-positions-test.ts

@@ -57,6 +57,7 @@ ATC-G-TTGC--
       for (const m of positions[i].getMonomers())
         expect(positions[i].getFreq(m).rowCount, resAllDf1[i].getFreq(m).rowCount);
     }
+    await wlViewer.awaitRendered();
   });
 
   test('positions with shrinkEmptyTail option true (filtered)', async () => {
@@ -106,6 +107,7 @@ ATC-G-TTGC--
       for (const m of positions[i].getMonomers())
         expect(positions[i].getFreq(m).rowCount, resAllDf1[i].getFreq(m).rowCount);
     }
+    await wlViewer.awaitRendered();
   });
 
   test('positions with skipEmptyPositions option', async () => {
@@ -143,6 +145,7 @@ ATC-G-TTGC--
       const tgtPos = tgtPosList[posI];
       expectPositionInfo(resPos, tgtPos);
     }
+    await wlViewer.awaitRendered();
   });
 
   test('count sequences for monomer at position', async () => {
@@ -178,6 +181,7 @@ ATC-G-TTGC--
     const uh = UnitsHandler.getOrCreate(seqCol);
     const countAt1 = countForMonomerAtPosition(df, uh, df.filter, 'G', atPI1);
     expect(countAt1, 5);
+    await wlViewer.awaitRendered();
   });
 
   test('empty', async () => {
@@ -196,6 +200,7 @@ ATC-G-TTGC--
       tv.dockManager.dock(wlViewer.root, DG.DOCK_TYPE.DOWN);
     }, 500);
     const resPosList: PI[] = wlViewer['positions'];
+    await wlViewer.awaitRendered();
   });
 });
 

package/src/tests/WebLogo-project-tests.ts

@@ -0,0 +1,63 @@
+import * as DG from 'datagrok-api/dg';
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+
+import wu from 'wu';
+
+import {category, delay, expect, test, testViewer} from '@datagrok-libraries/utils/src/test';
+
+import {awaitGrid} from './utils';
+import {WebLogoViewer} from '../viewers/web-logo-viewer';
+
+import {_package} from '../package-test';
+
+const PROJECT_PREFIX: string = 'Tests.Bio.WebLogo-project';
+
+category('WebLogo-project', () => {
+  test('fasta', async () => {
+    const prjName = `${PROJECT_PREFIX}.fasta`;
+    const df = await _package.files.readCsv('tests/filter_FASTA.csv');
+    const tableName = df.name;
+    const col = df.getCol('fasta');
+    await grok.data.detectSemanticTypes(df);
+    const view = grok.shell.addTableView(df);
+    const wlViewer = await df.plot.fromType('WebLogo',
+      {sequenceColumnName: col.name}) as unknown as WebLogoViewer;
+    view.dockManager.dock(wlViewer);
+    await wlViewer.awaitRendered();
+    await awaitGrid(view.grid);
+
+    await uploadProject(prjName, df.getTableInfo(), view, df);
+    grok.shell.closeAll();
+    await delay(500);
+
+    const prj2 = await grok.dapi.projects.open(prjName);
+    const view2 = grok.shell.getTableView(tableName);
+
+    const viewersA = wu(view2.viewers).toArray();
+    expect(viewersA.length, 2);
+    expect(viewersA.filter((f) => f.type === 'Grid').length, 1);
+    const wlViewer2 = viewersA.find((f) => f.type === 'WebLogo') as WebLogoViewer;
+    expect(!!wlViewer2, true);
+
+    await awaitGrid(view.grid);
+    await wlViewer2.awaitRendered();
+    // TODO: Check WebLogo viewer content
+  }, {skipReason: 'depends on 1.18'});
+});
+
+export async function uploadProject(projectName: string, tableInfo: DG.TableInfo,
+  view: DG.TableView, df: DG.DataFrame): Promise<void> {
+  const project = DG.Project.create();
+  const viewLayout = view.saveLayout();
+
+  await grok.dapi.layouts.save(view.saveLayout());
+  await grok.dapi.tables.uploadDataFrame(df);
+  await grok.dapi.tables.save(tableInfo);
+
+  project.name = projectName;
+  project.addChild(tableInfo);
+  project.addChild(viewLayout); // cause error
+
+  await grok.dapi.projects.save(project);
+}

package/src/tests/activity-cliffs-tests.ts

@@ -10,8 +10,9 @@ import {MmDistanceFunctionsNames} from '@datagrok-libraries/ml/src/macromolecule
 import {BitArrayMetricsNames} from '@datagrok-libraries/ml/src/typed-metrics';
 import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {
-  getUserLibSettings, LibSettings, setUserLibSettings, setUserLibSettingsForTests
+  getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
+import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 
 import {_package} from '../package-test';
 import {DimReductionMethods} from '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/types';
@@ -23,7 +24,7 @@ category('activityCliffs', async () => {
 
   let monomerLibHelper: IMonomerLibHelper;
   /** Backup actual user's monomer libraries settings */
-  let userLibSettings: LibSettings;
+  let userLibSettings: UserLibSettings;
   const seqEncodingFunc = DG.Func.find({name: 'macromoleculePreprocessingFunction', package: 'Bio'})[0];
   const helmEncodingFunc = DG.Func.find({name: 'helmPreprocessingFunction', package: 'Bio'})[0];
   before(async () => {

package/src/tests/monomer-libraries-tests.ts

@@ -6,9 +6,10 @@ import {test, after, before, category, expect} from '@datagrok-libraries/utils/s
 
 import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {
-  getUserLibSettings, LibSettings, setUserLibSettings, setUserLibSettingsForTests
+  getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
-import {getLibFileNameList} from '../utils/monomer-lib';
+import {MonomerLibFileManager} from '../utils/monomer-lib/library-file-manager/file-manager';
+import {MonomerLibFileEventManager} from '../utils/monomer-lib/library-file-manager/event-manager';
 
 
 category('monomerLibraries', () => {
@@ -50,7 +51,9 @@ category('monomerLibraries', () => {
   test('empty', async () => {
     // exclude all monomer libraries for empty set
     const libSettings = await getUserLibSettings();
-    const libFnList = await getLibFileNameList();
+    const libFileEventManager = MonomerLibFileEventManager.getInstance();
+    const libFileManager = await MonomerLibFileManager.getInstance(libFileEventManager);
+    const libFnList = libFileManager.getValidLibraryPaths();
     libSettings.exclude = libFnList;
     libSettings.explicit = [];
     await setUserLibSettings(libSettings);
@@ -59,5 +62,5 @@ category('monomerLibraries', () => {
     const currentMonomerLib = monomerLibHelper.getBioLib();
     expect(currentMonomerLib.getPolymerTypes().length === 0, true);
     const monomerOfTypesList = currentMonomerLib.getMonomerMolsByPolymerType('PEPTIDE');
-  });
+  }, {skipReason: '#2690'});
 });

package/src/tests/scoring.ts

@@ -8,8 +8,9 @@ import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/sr
 
 import {sequenceIdentityScoring, sequenceSimilarityScoring} from '../package';
 import {
-  LibSettings, getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests
+  getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
+import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 
 category('Scoring', () => {
   const sequence = 'sequence';
@@ -29,7 +30,7 @@ PEPTIDE1{[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[
 
   let monomerLibHelper: IMonomerLibHelper;
   /** Backup actual user's monomer libraries settings */
-  let userLibSettings: LibSettings;
+  let userLibSettings: UserLibSettings;
 
   before(async () => {
     monomerLibHelper = await getMonomerLibHelper();

package/src/tests/substructure-filters-tests.ts

@@ -5,8 +5,9 @@ import * as DG from 'datagrok-api/dg';
 import {after, before, category, test, expect, delay, testEvent, awaitCheck} from '@datagrok-libraries/utils/src/test';
 import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {
-  LibSettings, getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests
+  getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
+import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 
 import {awaitGrid, readDataframe} from './utils';
 import {
@@ -21,7 +22,7 @@ import {_package} from '../package-test';
 category('substructureFilters', async () => {
   let monomerLibHelper: IMonomerLibHelper;
   /** Backup actual user's monomer libraries settings */
-  let userLibSettings: LibSettings;
+  let userLibSettings: UserLibSettings;
 
   before(async () => {
     monomerLibHelper = await getMonomerLibHelper();

package/src/tests/to-atomic-level-tests.ts

@@ -11,8 +11,9 @@ import {IMonomerLib} from '@datagrok-libraries/bio/src/types/index';
 import {ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {
-  getUserLibSettings, LibSettings, setUserLibSettings, setUserLibSettingsForTests
+  getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
+import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 
 import {toAtomicLevel} from '../package';
@@ -56,7 +57,7 @@ category('toAtomicLevel', async () => {
 
   let monomerLibHelper: IMonomerLibHelper;
   /** Backup actual user's monomer libraries settings */
-  let userLibSettings: LibSettings;
+  let userLibSettings: UserLibSettings;
 
   before(async () => {
     monomerLibHelper = await getMonomerLibHelper();

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

@@ -5,11 +5,11 @@ import * as DG from 'datagrok-api/dg';
 
 import {MolfileHandler} from '@datagrok-libraries/chem-meta/src/parsing-utils/molfile-handler';
 import {MolfileHandlerBase} from '@datagrok-libraries/chem-meta/src/parsing-utils/molfile-handler-base';
-import {RDMol, RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
+import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
 import {HELM_POLYMER_TYPE, HELM_RGROUP_FIELDS} from '@datagrok-libraries/bio/src/utils/const';
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
 
-import {MonomerLibHelper} from './monomer-lib';
+import {MonomerLibManager} from './monomer-lib/lib-manager';
 
 import {_package} from '../package';
 
@@ -173,7 +173,7 @@ class MonomerWrapper {
     monomerSymbol: string,
     polymerType: HELM_POLYMER_TYPE,
   ) {
-    const monomerLib = MonomerLibHelper.instance.getBioLib();
+    const monomerLib = MonomerLibManager.instance.getBioLib();
     const monomer = monomerLib.getMonomer(polymerType, monomerSymbol);
     if (!monomer)
       throw new Error(`Monomer ${monomerSymbol} is not found in the library`);

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

@@ -0,0 +1,116 @@
+/* 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 {IMonomerLib} from '@datagrok-libraries/bio/src/types/index';
+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,
+} 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 };
+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({});
+
+  /** Protect constructor to prevent multiple instantiation. */
+  protected constructor() {}
+
+  /** Singleton monomer library
+   * @return {MonomerLibManager} MonomerLibHelper instance
+   */
+  getBioLib(): IMonomerLib {
+    return this._monomerLib;
+  }
+
+  /** 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 () => {
+      // WARNING: 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[], UserLibSettings] = await Promise.all([
+          getLibFileNameList(),
+          getUserLibSettings(),
+        ]);
+        const filteredLibFnList = libFileNameList
+          .filter((libFileName) => !settings.exclude.includes(libFileName))
+          .filter((libFileName) => settings.explicit.length > 0 ? settings.explicit.includes(libFileName) : true);
+        const libs: IMonomerLib[] = await Promise.all(filteredLibFnList
+          .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
+   * @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> {
+    const eventManager = MonomerLibFileEventManager.getInstance();
+    const libFileManager = await MonomerLibFileManager.getInstance(eventManager);
+    const lib: IMonomerLib = await libFileManager.loadLibraryFromFile(path, fileName);
+    return lib;
+  }
+
+  /** Reset user settings to the specified library. WARNING: clears user * settings */
+  public async selectSpecifiedLibraries(libFileNameList: string[]): Promise<void> {
+    const invalidNames = await this.getInvalidFileNames(libFileNameList);
+    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));
+    await setUserLibSettings(settings);
+  }
+
+  private async getInvalidFileNames(libFileNameList: string[]): Promise<string[]> {
+    const availableFileNames = await getLibFileNameList();
+    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;
+  }
+}

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

@@ -0,0 +1 @@
+export const HELM_JSON_SCHEMA_PATH = 'System:AppData/Bio/tests/libraries/HELMmonomerSchema.json';

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

@@ -0,0 +1,80 @@
+/* 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 {createJsonMonomerLibFromSdf} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import {PolyToolMonomerLibHandler} from '../../poly-tool/monomer-lib-handler';
+
+interface CustomMonomerLibHandler {
+  getHelmLibContent(): Promise<string>;
+}
+
+/** Casts specific SDF files as HELM-standard monomer libraries */
+export class SdfMonomerLibHandler implements CustomMonomerLibHandler {
+  constructor(private fileName: string, private fileContent: string) {
+    this.validateChemInstallation();
+    this.validate();
+  }
+
+  async getHelmLibContent(): Promise<string> {
+    const bytes = this.transformToBytes();
+    const dfSdf = await grok.functions.call('Chem:importSdf', {bytes});
+    const jsonContent = createJsonMonomerLibFromSdf(dfSdf[0]);
+    return JSON.stringify(jsonContent);
+  }
+
+  private transformToBytes(): Uint8Array {
+    return new TextEncoder().encode(this.fileContent);
+  }
+
+  private validateChemInstallation(): void {
+    const funcList: DG.Func[] = DG.Func.find({package: 'Chem', name: 'importSdf'});
+    if (funcList.length === 1)
+      return;
+    throw new Error('MonomerLibFileManager: Chem package is not installed, cannot convert SDF to JSON');
+  }
+
+  private validate(): void {
+    if (!this.fileName.endsWith('.sdf'))
+      throw new Error(`File ${this.fileName} is not an SDF file`);
+  }
+}
+
+
+/** Handler of custom monomer libs for PolyTool  */
+export class PolyToolCsvLibHandler implements CustomMonomerLibHandler {
+  constructor(private fileName: string, private fileContent: string) {
+    this.validateFileType();
+    const df = DG.DataFrame.fromCsv(this.fileContent);
+    const json = this.toJson(df);
+    this.polyToolMonomerLib = new PolyToolMonomerLibHandler(json);
+    this.validateContent();
+  }
+
+  private polyToolMonomerLib: PolyToolMonomerLibHandler;
+
+  async getHelmLibContent(): Promise<string> {
+    const rawLibData = this.polyToolMonomerLib.getJsonMonomerLib();
+    return JSON.stringify(rawLibData);
+  }
+
+  private toJson(df: DG.DataFrame): any[] {
+    return Array.from({length: df.rowCount}, (_, idx) =>
+      df.columns.names().reduce((entry: { [key: string]: any }, colName) => {
+        entry[colName] = df.get(colName, idx);
+        return entry;
+      }, {})
+    );
+  }
+
+  private validateFileType(): void {
+    if (!this.fileName.endsWith('.csv'))
+      throw new Error(`File ${this.fileName} is not an CSV file`);
+  }
+
+  private validateContent(): void {
+    if (!this.polyToolMonomerLib.isValid())
+      throw new Error('Invalid format of CSV monomer lib');
+  }
+}

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

@@ -0,0 +1,58 @@
+import * as rxjs from 'rxjs';
+import {debounceTime, tap} from 'rxjs/operators';
+
+export class MonomerLibFileEventManager {
+  // WARNING: this must be a singleton because it manages the unique state
+  private constructor() {}
+
+  private static _instance: MonomerLibFileEventManager;
+
+  static getInstance(): MonomerLibFileEventManager {
+    if (!MonomerLibFileEventManager._instance)
+      MonomerLibFileEventManager._instance = new MonomerLibFileEventManager();
+
+    return MonomerLibFileEventManager._instance;
+  }
+
+  private _libraryFilesUpdateSubject$ = new rxjs.BehaviorSubject<string[]>([]);
+  private _addLibraryFilesSubject$ = new rxjs.Subject<void>();
+  private _librarySelectionSubject$ = new rxjs.Subject<[string, boolean]>();
+
+  getValidFilesPathList(): string[] {
+    return this._libraryFilesUpdateSubject$.getValue();
+  }
+
+  changeValidFilesPathList(newList: string[]): void {
+    this._libraryFilesUpdateSubject$.next(newList);
+  }
+
+  get updateUIControlsRequested$(): rxjs.Observable<string[]> {
+    return this._libraryFilesUpdateSubject$.pipe(
+      // debounceTime(1000)
+    );
+  }
+
+  get updateValidLibraryFileListRequested$(): rxjs.Observable<string[]> {
+    return this._libraryFilesUpdateSubject$.pipe(
+      // debounceTime(3000)
+    );
+  }
+
+  get addLibraryFileRequested$(): rxjs.Observable<void> {
+    return this._addLibraryFilesSubject$.pipe(
+      // debounceTime(1000)
+    );
+  }
+
+  addLibraryFile(): void {
+    this._addLibraryFilesSubject$.next();
+  }
+
+  get librarySelectionRequested$(): rxjs.Observable<[string, boolean]> {
+    return this._librarySelectionSubject$;
+  }
+
+  updateLibrarySelectionStatus(fileName: string, isSelected: boolean): void {
+    this._librarySelectionSubject$.next([fileName, isSelected]);
+  }
+}