@datagrok/bio 2.13.8 → 2.14.2

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

@@ -5,9 +5,9 @@ import * as DG from 'datagrok-api/dg';
 
 import {delay} from '@datagrok-libraries/utils/src/test';
 import {ILogger} from '@datagrok-libraries/bio/src/utils/logger';
-import {IMonomerLib} from '@datagrok-libraries/bio/src/types';
+import {IMonomerLib, IMonomerSet} from '@datagrok-libraries/bio/src/types';
 import {
-  getUserLibSettings, setUserLibSettings, LIB_PATH
+  getUserLibSettings, setUserLibSettings, LIB_PATH, SETS_PATH
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 import {
@@ -15,6 +15,7 @@ import {
 } from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 
 import {MonomerLib} from './monomer-lib';
+import {MonomerSet} from './monomer-set';
 import {MonomerLibFileManager} from './library-file-manager/file-manager';
 import {MonomerLibFileEventManager} from './library-file-manager/event-manager';
 
@@ -27,6 +28,7 @@ declare const window: MonomerLibWindowType;
  * the platform  */
 export class MonomerLibManager implements IMonomerLibHelper {
   private readonly _monomerLib = new MonomerLib({}, 'MAIN');
+  private readonly _monomerSets = new MonomerSet('MAIN', []);
 
   private _eventManager: MonomerLibFileEventManager;
 
@@ -54,13 +56,33 @@ export class MonomerLibManager implements IMonomerLibHelper {
     private readonly logger: ILogger,
   ) {}
 
+  private static objCounter: number = -1;
+  private readonly objId: number = (() => {
+    if (++MonomerLibManager.objCounter > 0)
+      throw new Error('MonomerLibManager MUST be a singleton.');
+    return MonomerLibManager.objCounter;
+  })();
+
+  protected toLog(): string {
+    return `MonomerLibManager<${this.objId}>`;
+  }
+
   /** Singleton monomer library
    * @return {MonomerLibManager} MonomerLibHelper instance
    */
-  getBioLib(): IMonomerLib {
+  getMonomerLib(): IMonomerLib {
     return this._monomerLib;
   }
 
+  /**  @deprecated Use {@link v} */
+  getBioLib(): IMonomerLib {
+    return this.getMonomerLib();
+  }
+
+  getMonomerSets(): IMonomerSet {
+    return this._monomerSets;
+  }
+
   /** Instance promise of {@link getFileManager} */
   private _fileManagerPromise?: Promise<MonomerLibFileManager>;
 
@@ -81,17 +103,21 @@ export class MonomerLibManager implements IMonomerLibHelper {
   /** 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
+  async loadMonomerLib(reload: boolean = false): Promise<void> {
+    const logPrefix = `${this.toLog()}.loadMonomerLib()`;
+    this.logger.debug(`${logPrefix}, start`);
+    this.loadLibrariesPromise = this.loadLibrariesPromise.then(async () => {
+      this.logger.debug(`${logPrefix}, IN`);
+
       const pi = DG.TaskBarProgressIndicator.create('Loading monomers ...');
       try {
-        const [libFileNameList, settings]: [string[], UserLibSettings] = await Promise.all([
-          (await this.getFileManager()).getValidLibraryPaths(),
-          getUserLibSettings(),
-        ]);
+        const [[libFileNameList,], settings]: [[string[],], UserLibSettings] =
+          await Promise.all([
+            await this.getFileManager().then((fileManager) => {
+              return [fileManager.getValidLibraryPaths(),];
+            }),
+            getUserLibSettings(),
+          ]);
 
         const filteredLibFnList = libFileNameList.filter((libFileName) => {
           const isFileIncluded = !settings.exclude.includes(libFileName);
@@ -100,32 +126,97 @@ export class MonomerLibManager implements IMonomerLibHelper {
           return isFileIncluded && isExplicit;
         });
 
-        let completedLibCount: number = 0;
-        const libs: IMonomerLib[] = await Promise.all(filteredLibFnList
-          .map((libFileName) => {
-            //TODO handle whether files are in place
+        let completedFileCount: number = 0;
+        const allCount: number = filteredLibFnList.length;
+        const [libs,]: [IMonomerLib[],] = await Promise.all([
+          Promise.all(filteredLibFnList.map((libFileName) => {
             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({}, libFileName, errMsg);
-              }).finally(() => {
-                pi.update(Math.round(100 * (++completedLibCount) / filteredLibFnList.length),
-                  `Loading monomer libs ${completedLibCount}/${filteredLibFnList.length}`);
+              })
+              .finally(() => {
+                pi.update(Math.round(100 * (++completedFileCount) / allCount),
+                  `Loading monomers ${completedFileCount}/${allCount}`);
               });
-          }));
+          })),]);
         this._monomerLib.updateLibs(libs, reload);
       } catch (err: any) {
+        // WARNING: This function is not allowed to throw any exception,
+        // because it will prevent further handling monomer library settings
+        // through blocking this.loadLibrariesPromise
+
         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);
+        this.logger.error(errMsg, undefined, errStack);
       } finally {
         pi.close();
+        this.logger.debug(`${logPrefix}, OUT`);
       }
     });
+    this.logger.debug(`${logPrefix}, end`);
+    return this.loadLibrariesPromise;
+  }
+
+  /** @deprecated Use {@link loadMonomerLib} */
+  async loadLibraries(reload?: boolean): Promise<void> {
+    return this.loadMonomerLib(reload);
+  }
+
+  private loadSetsPromise: Promise<void> = Promise.resolve();
+
+  async loadMonomerSets(reload: boolean = false): Promise<void> {
+    const logPrefix = `${this.toLog()}.loadMonomerSets()`;
+
+    this.logger.debug(`${logPrefix}, start`);
+    this.loadSetsPromise = this.loadSetsPromise.then(async () => {
+      this.logger.debug(`${logPrefix}, IN`);
+      const pi = DG.TaskBarProgressIndicator.create(`Loading monomer sets ...`);
+      try {
+        const [[setFileNameList,]]: [[string[],],] = await Promise.all([
+          await this.getFileManager().then((fileManager) => {
+            return [fileManager.getValidSetPaths(),];
+          })
+        ]);
+
+        // TODO: Filter for settings
+        const filteredSetFnList = setFileNameList.filter((setFileName) => true);
+
+        let completedFileCount: number = 0;
+        const allCount: number = filteredSetFnList.length;
+        const [sets,]: [IMonomerSet[],] = await Promise.all([
+          Promise.all(filteredSetFnList.map((setFileName) => {
+            // TODO: handle whether files are in place
+            return this.readSet(SETS_PATH, setFileName)
+              .catch((err: any) => {
+                const errMsg: string = `Loading monomer sets from '${setFileName}' error: ` +
+                  `${err instanceof Error ? err.message : err.toString()}`;
+                return new MonomerSet('Broken monomer set', [], setFileName, errMsg);
+              })
+              .finally(() => {
+                pi.update(Math.round(100 * (++completedFileCount) / allCount),
+                  `Loading monomers ${completedFileCount}/${allCount}`);
+              });
+          })),]);
+        this._monomerSets.updateSets(sets);
+      } catch (err: any) {
+        const errMsg: string = 'Loading monomer sets error: ' +
+          `${err instanceof Error ? err.message : err.toString()}`;
+        grok.shell.warning(errMsg);
+
+        const errStack = err instanceof Error ? err.stack : undefined;
+        this.logger.error(errMsg, undefined, errStack);
+      } finally {
+        pi.close();
+        this.logger.debug(`${logPrefix}, OUT`);
+      }
+    });
+    this.logger.debug(`${logPrefix}, end`);
+    return this.loadSetsPromise;
   }
 
   /** Reads library from file shares, handles .json and .sdf
@@ -139,6 +230,12 @@ export class MonomerLibManager implements IMonomerLibHelper {
     return lib;
   }
 
+  async readSet(path: string, fileName: string): Promise<IMonomerSet> {
+    const fileManager = await this.getFileManager();
+    const set: IMonomerSet = await fileManager.loadSetFromFile(this._monomerLib, path, fileName);
+    return set;
+  }
+
   /** Reset user settings to the specified library. WARNING: clears user * settings */
   public async selectSpecifiedLibraries(libFileNameList: string[]): Promise<void> {
     const invalidNames = await this.getInvalidFileNames(libFileNameList);

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

@@ -20,42 +20,59 @@ export class MonomerLibFileEventManager implements IMonomerLibFileEventManager {
     return MonomerLibFileEventManager._instance;
   }
 
-  private _libraryFilesUpdateSubject$ = new BehaviorSubject<string[]>([]);
+  private _libFilesUpdateSubject$ = new BehaviorSubject<string[]>([]);
+  private _setFilesUpdateSubject$ = new BehaviorSubject<string[]>([]);
+
   private _addLibraryFilesSubject$ = new Subject<void>();
   private _librarySelectionSubject$ = new Subject<[string, boolean]>();
 
-  getValidFilesPathList(): string[] {
-    return this._libraryFilesUpdateSubject$.getValue();
+  getValidLibPathList(): string[] {
+    return this._libFilesUpdateSubject$.getValue();
+  }
+
+  getValidSetPathList(): string[] {
+    return this._setFilesUpdateSubject$.getValue();
   }
 
   // TODO: remove after adding init from user data storage
   // WARNING: a temporary solution
   async getValidLibraryPathsAsynchronously(): Promise<string[]> {
     return new Promise((resolve) => {
-      this._libraryFilesUpdateSubject$.pipe<string[]>(
+      const sub = this._libFilesUpdateSubject$.pipe<string[]>(
         skip(1)
       ).subscribe((fileNames) => {
         resolve(fileNames);
+        sub.unsubscribe();
       });
     });
   }
 
-  changeValidFilesPathList(newList: string[]): void {
-    this._libraryFilesUpdateSubject$.next(newList);
+  changeValidLibPathList(newLibPathList: string[]): void {
+    this._libFilesUpdateSubject$.next(newLibPathList);
+  }
+
+  changeValidSetPathList(newSetPathList: string[]): void {
+    this._setFilesUpdateSubject$.next(newSetPathList);
   }
 
   get updateUIControlsRequested$(): Observable<string[]> {
-    return this._libraryFilesUpdateSubject$.pipe(
+    return this._libFilesUpdateSubject$.pipe(
       // debounceTime(1000)
     );
   }
 
   get updateValidLibraryFileListRequested$(): Observable<string[]> {
-    return this._libraryFilesUpdateSubject$.pipe(
+    return this._libFilesUpdateSubject$.pipe(
       // debounceTime(3000)
     );
   }
 
+  get updateValidSetFileListRequested$(): Observable<string[]> {
+    return this._setFilesUpdateSubject$.pipe(
+      // debounceTime(1000)
+    );
+  }
+
   get addLibraryFileRequested$(): Observable<void> {
     return this._addLibraryFilesSubject$.pipe(
       // debounceTime(1000)

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

@@ -5,9 +5,10 @@ import * as DG from 'datagrok-api/dg';
 
 import {JSONSchemaType} from 'ajv';
 
-import {IMonomerLib, Monomer} from '@datagrok-libraries/bio/src/types';
+import {MonomerType, PolymerType} from '@datagrok-libraries/bio/src/helm/types';
+import {IMonomerLib, IMonomerLinkData, IMonomerSet, Monomer} from '@datagrok-libraries/bio/src/types';
 import {ILogger} from '@datagrok-libraries/bio/src/utils/logger';
-import {LIB_PATH} from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
+import {LIB_PATH, SETS_PATH} from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {
   HELM_REQUIRED_FIELD as REQ,
 } from '@datagrok-libraries/bio/src/utils/const';
@@ -19,6 +20,7 @@ import {MonomerLib} from '../monomer-lib';
 import {HELM_JSON_SCHEMA_PATH} from './consts';
 import {MonomerLibFileEventManager} from './event-manager';
 import {MonomerLibFileValidator} from './file-validator';
+import {MonomerSet, MonomerSetPlaceholder} from '../monomer-set';
 
 import {_package} from '../../../package';
 
@@ -34,8 +36,11 @@ export class MonomerLibFileManager implements IMonomerLibFileManager {
     public readonly eventManager: MonomerLibFileEventManager,
     private readonly logger: ILogger,
   ) {
-    this.eventManager.updateValidLibraryFileListRequested$.subscribe(async () => {
-      await this.updateValidLibraryList();
+    const _libSub = this.eventManager.updateValidLibraryFileListRequested$.subscribe(() => {
+      this.updateValidLibList().then(() => {});
+    });
+    const _setSub = this.eventManager.updateValidSetFileListRequested$.subscribe(() => {
+      this.updateValidSetList().then(() => {});
     });
   }
 
@@ -68,7 +73,7 @@ export class MonomerLibFileManager implements IMonomerLibFileManager {
 
       await this.validateAgainstHELM(fileContent, fileName);
       await grok.dapi.files.writeAsText(LIB_PATH + `${fileName}`, fileContent);
-      await this.updateValidLibraryList();
+      await this.updateValidLibList();
       const fileExists = await grok.dapi.files.exists(LIB_PATH + `${fileName}`);
       if (!fileExists)
         grok.shell.error(`Failed to add ${fileName} library`);
@@ -83,7 +88,7 @@ export class MonomerLibFileManager implements IMonomerLibFileManager {
   async deleteLibraryFile(fileName: string): Promise<void> {
     try {
       await grok.dapi.files.delete(LIB_PATH + `${fileName}`);
-      await this.updateValidLibraryList();
+      await this.updateValidLibList();
       grok.shell.info(`Deleted ${fileName} library`);
     } catch (e) {
       console.error(e);
@@ -115,8 +120,31 @@ export class MonomerLibFileManager implements IMonomerLibFileManager {
     return new MonomerLib(monomers, fileName);
   }
 
+  async loadSetFromFile(monomerLib: IMonomerLib, path: string, fileName: string): Promise<IMonomerSet> {
+    let raw: any = {};
+    const fileSource = new DG.FileSource(path);
+    const content = await fileSource.readAsText(fileName);
+    raw = JSON.parse(content);
+
+    const description = raw['description'];
+    const placeholders = Object.entries(raw['placeholders']).map(([k, v]: [string, any]) => {
+      const placeholderSymbol = k;
+      const polymerType = v['polymerType'] as PolymerType;
+      const monomerType = v['monomerType'] as MonomerType;
+      const monomerLinks = v['set'] as IMonomerLinkData[];
+
+      return new MonomerSetPlaceholder(monomerLib, placeholderSymbol, polymerType, monomerType, monomerLinks);
+    });
+
+    return new MonomerSet(description, placeholders);
+  }
+
   getValidLibraryPaths(): string[] {
-    return this.eventManager.getValidFilesPathList();
+    return this.eventManager.getValidLibPathList();
+  }
+
+  getValidSetPaths(): string[] {
+    return this.eventManager.getValidSetPathList();
   }
 
   // TODO: remove after adding init from user data storage
@@ -125,21 +153,21 @@ export class MonomerLibFileManager implements IMonomerLibFileManager {
     return await this.eventManager.getValidLibraryPathsAsynchronously();
   }
 
-  private async updateValidLibraryList(): Promise<void> {
-    const logPrefix: string = `${this.toLog()}.updateValidLibraryList()`;
+  private async updateValidLibList(): Promise<void> {
+    const logPrefix: string = `${this.toLog()}.updateValidLibList()`;
     this.logger.debug(`${logPrefix}, start`);
     this.filesPromise = this.filesPromise.then(async () => {
       this.logger.debug(`${logPrefix}, IN`);
       const invalidFiles = [] as string[];
       // console.log(`files before validation:`, this.libraryEventManager.getValidFilesPathList());
-      const filePaths = await this.getFilePathsAtDefaultLocation();
+      const libPathList = await this.getLibFileListAtLocation();
 
-      if (!this.fileListHasChanged(filePaths)) {
+      if (!this.libListHasChanged(libPathList)) {
         this.logger.debug(`${logPrefix}, end, not changed`);
         return;
       }
 
-      for (const path of filePaths) {
+      for (const path of libPathList) {
         if (!path.endsWith('.json')) {
           invalidFiles.push(path);
           continue;
@@ -150,16 +178,16 @@ export class MonomerLibFileManager implements IMonomerLibFileManager {
           invalidFiles.push(path);
       }
 
-      const validLibraryPaths = filePaths.filter((path) => !invalidFiles.includes(path));
+      const validLibPathList = libPathList.filter((path) => !invalidFiles.includes(path));
 
-      if (this.fileListHasChanged(validLibraryPaths)) {
-        this.eventManager.changeValidFilesPathList(validLibraryPaths);
-        this.libHelper.loadLibraries(true);
+      if (this.libListHasChanged(validLibPathList)) {
+        this.eventManager.changeValidLibPathList(validLibPathList);
+        this.libHelper.loadMonomerLib(true);
       }
       // console.log(`files after validation:`, this.libraryEventManager.getValidFilesPathList());
 
-      if (validLibraryPaths.some((el) => !el.endsWith('.json')))
-        this.logger.warning(`Wrong validation: ${validLibraryPaths}`);
+      if (validLibPathList.some((el) => !el.endsWith('.json')))
+        this.logger.warning(`Wrong validation: ${validLibPathList}`);
 
       if (invalidFiles.length > 0) {
         const message = `Invalid monomer library files in ${LIB_PATH}` +
@@ -174,8 +202,50 @@ export class MonomerLibFileManager implements IMonomerLibFileManager {
     return this.filesPromise;
   }
 
-  private fileListHasChanged(newList: string[]): boolean {
-    const currentList = this.eventManager.getValidFilesPathList();
+  private async updateValidSetList(): Promise<void> {
+    const logPrefix: string = `${this.toLog()}.updateValidSetList()`;
+    _package.logger.debug(`${logPrefix}, start`);
+    this.filesPromise = this.filesPromise.then(async () => {
+      _package.logger.debug(`${logPrefix}, IN`);
+      const invalidFiles = [] as string[];
+      const setPathList: string[] = await this.getSetFileListAtLocation();
+
+      if (!this.setListHasChanged(setPathList)) {
+        _package.logger.debug(`${logPrefix}, end, not changed`);
+        return;
+      }
+
+      for (const path of setPathList) {
+        if (!path.endsWith('.json')) {
+          invalidFiles.push(path);
+          continue;
+        }
+
+        const fileContent = await grok.dapi.files.readAsText(SETS_PATH + `${path}`);
+        // TODO: Validate monomer set
+        // if (!this.isValidMonomerSet(fileContent, path))
+        //   invalidFiles.push(path);
+      }
+
+      const validSetPathList = setPathList.filter((path) => !invalidFiles.includes(path));
+      if (this.setListHasChanged(validSetPathList)) {
+        this.eventManager.changeValidSetPathList(validSetPathList);
+        this.libHelper.loadMonomerSets(true);
+      }
+
+      _package.logger.debug(`${logPrefix}, OUT`);
+    });
+    _package.logger.debug(`${logPrefix}, end`);
+    return this.filesPromise;
+  }
+
+  private libListHasChanged(newList: string[]): boolean {
+    const currentList = this.eventManager.getValidLibPathList();
+    return newList.length !== currentList.length || newList.some((el, i) => el !== currentList[i]);
+  }
+
+  private setListHasChanged(newList: string[]): boolean {
+    const currentList = this.eventManager.getValidSetPathList();
     return newList.length !== currentList.length || newList.some((el, i) => el !== currentList[i]);
   }
 
@@ -189,31 +259,48 @@ export class MonomerLibFileManager implements IMonomerLibFileManager {
     return this.fileValidator.validateFile(fileContent, fileName);
   }
 
-  /** Get relative paths for files in LIB_PATH  */
-  private async getFilePathsAtDefaultLocation(): Promise<string[]> {
-    const logPrefix = `${this.toLog()}.getFilePathsAtDefaultLocation()`;
+  /** Get relative paths for files in LIB_PATH, SET_PATH  */
+  private async getLibFileListAtLocation(): Promise<string[]> {
+    const logPrefix = `${this.toLog()}.getLibFileListAtLocation()`;
     this.logger.debug(`${logPrefix}, start`);
-    const list = await grok.dapi.files.list(LIB_PATH);
-    const paths = list.map((fileInfo) => {
-      return fileInfo.fullPath;
-    });
+
+    const libPaths = await grok.dapi.files.list(LIB_PATH)
+      .then((l) => l.map((fi) => fi.fullPath));
 
     const checkForUi = false;
-    const existingPaths = [] as string[];
+    const existingLibPaths: string[] = [];
     if (checkForUi) {
       // WARNING: an extra sanity check,
       // caused by unexpected behavior of grok.dapi.files.list() when it returns non-existent paths
-      for (const path of paths) {
+      for (const path of libPaths) {
         const exists = await grok.dapi.files.exists(path);
         if (exists)
-          existingPaths.push(path);
+          existingLibPaths.push(path);
       }
     } else
-      existingPaths.push(...paths);
+      existingLibPaths.push(...libPaths);
 
-    return existingPaths.map((path) => {
-      // Get relative path (to LIB_PATH)
-      return path.substring(LIB_PATH.length);
-    });
+    return existingLibPaths.map((p) => /* relative to LIB_PATH */ p.substring(LIB_PATH.length));
+  }
+
+  private async getSetFileListAtLocation(): Promise<string[]> {
+    const logPrefix = `${this.toLog()}.getSetFileListAtLocation()`;
+    this.logger.debug(`${logPrefix}, start`);
+
+    const setPaths = await grok.dapi.files.list(SETS_PATH)
+      .then((l) => l.map((fi) => fi.fullPath));
+
+    const checkForUi = false;
+    const existingSetPaths: string[] = [];
+    if (checkForUi) {
+      for (const path of setPaths) {
+        const exists = await grok.dapi.files.exists(path);
+        if (exists)
+          existingSetPaths.push(path);
+      }
+    } else
+      existingSetPaths.push(...setPaths);
+
+    return existingSetPaths.map((p) => /* relative to SET_PATH */ p.substring(SETS_PATH.length));
   }
 }

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

@@ -157,7 +157,7 @@ class LibraryControlsManager {
     this.updateLibrarySettings(isMonomerLibrarySelected, libFileName);
     await setUserLibSettings(this.userLibSettings);
     const monomerLibHelper = await getMonomerLibHelper();
-    await monomerLibHelper.loadLibraries(true);
+    await monomerLibHelper.loadMonomerLib(true);
     grok.shell.info('Monomer library user settings saved');
   }
 

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

@@ -6,13 +6,14 @@ import * as DG from 'datagrok-api/dg';
 import wu from 'wu';
 import {Observable, Subject} from 'rxjs';
 
-import {MonomerType, PolymerType} from '@datagrok-libraries/bio/src/helm/types';
-import {IMonomerLib, Monomer, MonomerLibSummaryType, RGroup} from '@datagrok-libraries/bio/src/types';
+import {HelmType, MonomerSetType, MonomerType, PolymerType} from '@datagrok-libraries/bio/src/helm/types';
+import {IMonomerLib, IMonomerSet, Monomer, MonomerLibSummaryType, 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 {GapOriginals} from '@datagrok-libraries/bio/src/utils/seq-handler';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {PolymerTypes} from '@datagrok-libraries/bio/src/helm/consts';
+import {helmTypeToPolymerType} from '@datagrok-libraries/bio/src/monomer-works/monomer-works';
 
 import '../../../css/cell-renderer.css';
 
@@ -102,6 +103,20 @@ export class MonomerLib implements IMonomerLib {
     return res;
   }
 
+  private _monomerSets: { [biotype: string /*HelmType*/]: MonomerSetType } | null = null;
+
+  getMonomerSet(biotype: HelmType): MonomerSetType | null {
+    const polymerType: PolymerType = helmTypeToPolymerType(biotype);
+    if (!this._monomerSets)
+      this._monomerSets = {};
+    if (!(biotype in this._monomerSets)) {
+      for (const [monomerSymbol, monomer] of Object.entries(this._monomers[polymerType])) {
+
+      }
+    }
+    return this._monomerSets[biotype];
+  }
+
   getPolymerTypes(): PolymerType[] {
     return Object.keys(this._monomers) as PolymerType[];
   }
@@ -151,7 +166,7 @@ export class MonomerLib implements IMonomerLib {
     return this._onChanged;
   }
 
-  private _updateInt(lib: IMonomerLib): void {
+  private _updateLibInt(lib: IMonomerLib): void {
     const typesNew = lib.getPolymerTypes();
     const types = this.getPolymerTypes();
 
@@ -169,13 +184,15 @@ export class MonomerLib implements IMonomerLib {
   }
 
   public update(lib: IMonomerLib): void {
-    this._updateInt(lib);
+    this._updateLibInt(lib);
     this._onChanged.next();
   }
 
   public updateLibs(libList: IMonomerLib[], reload: boolean = false): void {
-    if (reload) this._monomers = {};
-    for (const lib of libList) if (!lib.error) this._updateInt(lib);
+    if (reload)
+      this._monomers = {};
+    for (const lib of libList)
+      if (!lib.error) this._updateLibInt(lib);
     this._onChanged.next();
   }
 

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

@@ -0,0 +1,61 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import type {MonomerType, PolymerType} from '@datagrok-libraries/bio/src/helm/types';
+import {
+  IMonomerLib, IMonomerLinkData, IMonomerSet, IMonomerSetPlaceholder, Monomer
+} from '@datagrok-libraries/bio/src/types';
+import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
+
+export class MonomerSetPlaceholder implements IMonomerSetPlaceholder {
+  public readonly monomers: Monomer[];
+
+  public readonly error: string | null = null;
+
+  constructor(
+    private readonly monomerLib: IMonomerLib,
+    public symbol: string,
+    public readonly polymerType: PolymerType,
+    public readonly monomerType: MonomerType,
+    public readonly monomerLinks: IMonomerLinkData[],
+  ) {
+    try {
+      this.monomers = this.monomerLinks.map((mLink) => {
+        const resM = this.monomerLib.getMonomer(this.polymerType, mLink.symbol);
+        if (!resM)
+          throw new Error('Monomer not found: ');
+        if (resM.lib?.source != mLink.source)
+          throw new Error(`Monomer '${symbol}' found in different library.`);
+        return resM;
+      });
+    } catch (err: any) {
+      const [errMsg, errStack] = errInfo(err);
+      this.error = errMsg;
+      this.monomers = [];
+    }
+  }
+}
+
+export class MonomerSet implements IMonomerSet {
+  public constructor(
+    public readonly description: string,
+    public placeholders: IMonomerSetPlaceholder[],
+    public readonly source: string | undefined = undefined,
+    public readonly error: string | undefined = undefined,
+  ) {}
+
+  updateSets(setList: IMonomerSet[], reload: boolean = false): void {
+    if (reload)
+      this.placeholders = [];
+    for (const _set of setList)
+      if (!_set.error) this._updateSetInt(_set);
+
+    // TODO: File onChanged
+  }
+
+  private _updateSetInt(set: IMonomerSet): void {
+    for (const setPh of set.placeholders)
+      this.placeholders.push(setPh);
+  }
+}