@datagrok/bio 2.11.30 → 2.11.33

package/src/utils/poly-tool/monomer-lib-handler.ts

@@ -0,0 +1,115 @@
+/* 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 {HELM_FIELDS, DUMMY_MONOMER} from '@datagrok-libraries/bio/src/utils/const';
+import {
+  helmFieldsToPolyToolInputFields, R_GROUP_BLOCK_DUMMY
+} from './const';
+import {Monomer, RGroup} from '@datagrok-libraries/bio/src/types/index';
+
+export class PolyToolMonomerLibHandler {
+  constructor(private rawLib: any[]) { }
+
+  isValid(): boolean {
+    return this.rawLib.every((entry) => {
+      return typeof entry === 'object' &&
+        Object.values(helmFieldsToPolyToolInputFields).every((field) => {
+          return field in entry &&
+            typeof entry[field] === 'string';
+        });
+    });
+  }
+
+  getJsonMonomerLib(): any {
+    const resultLib: any[] = [];
+    this.rawLib.forEach((rawMonomer) => {
+      const monomer = this.prepareMonomer(rawMonomer);
+      resultLib.push(monomer);
+    });
+    return resultLib;
+  }
+
+  private prepareMonomer(rawMonomer: any): Monomer {
+    const monomer: Monomer = {...DUMMY_MONOMER};
+
+    Object.entries(helmFieldsToPolyToolInputFields).forEach(([key, value]) => {
+      const monomerSymbol = rawMonomer[value] as string;
+      //@ts-ignore
+      monomer[key] = monomerSymbol;
+    });
+
+    let key = HELM_FIELDS.SMILES;
+    const rawSmiles = rawMonomer[helmFieldsToPolyToolInputFields[key]];
+    const smilesHandler = new SmilesHandler(rawSmiles);
+    const smiles = smilesHandler.getCappedSmiles();
+    monomer[key] = smiles;
+
+    key = HELM_FIELDS.RGROUPS;
+    monomer[key] = RGroupHandler.getRGroups(smilesHandler.getNumberOfRGroups());
+
+    key = HELM_FIELDS.MOLFILE;
+    monomer[key] = new MolBlockHandler(smilesHandler.getSmilesWithRGroups()).getMolfile();
+
+    return monomer;
+  }
+}
+
+class SmilesHandler {
+  constructor(rawSmiles: string) {
+    const regex = /\[R(\d+)\]/g;
+    let i = 0;
+    this.smilesWithRGroups = rawSmiles.replace(regex, (_, capturedDigit) => { ++i; return `[${capturedDigit}*]`; });
+    this.numberOfRGroups = i;
+  }
+
+  private numberOfRGroups: number;
+  private smilesWithRGroups: string;
+
+  getSmilesWithRGroups(): string {
+    return this.smilesWithRGroups;
+  }
+
+  getCappedSmiles(): string {
+    const smiles = this.capRGroups();
+    return smiles;
+  }
+
+  getNumberOfRGroups(): number {
+    return this.numberOfRGroups;
+  }
+
+  private capRGroups(): string {
+    let result = this.smilesWithRGroups.replace('[1*]', '[H:1]');
+    result = result.replace('[2*]', '[OH:2]');
+    return result.replace('[3*]', '[H:3]');
+  }
+}
+
+class RGroupHandler {
+  private constructor() {};
+
+  static getRGroups(numberOfRGroups: number): RGroup[] {
+    return R_GROUP_BLOCK_DUMMY.slice(0, numberOfRGroups);
+  }
+}
+
+class MolBlockHandler {
+  constructor(private smilesWithRGroups: string) { }
+
+  getMolfile(): string {
+    let molfile = DG.chem.convert(this.smilesWithRGroups, DG.chem.Notation.Smiles, DG.chem.Notation.MolBlock);
+    molfile = this.restoreRGPLine(molfile);
+    molfile = this.fixRGroupSymbols(molfile);
+    return molfile;
+  }
+
+  private restoreRGPLine(rawMolfile: string): string {
+    return rawMolfile.replace('M  ISO', 'M  RGP');
+  }
+
+  private fixRGroupSymbols(molfile: string): string {
+    return molfile.replace(/\bR\b/g, 'R#');
+  }
+}

package/src/utils/poly-tool/types.ts

@@ -12,3 +12,9 @@ export type ConnectionData = {
   attachmentPoint: number,
 }
 
+export type PolyToolLib = {
+  'Short Name': string,
+  'Medium Name': string,
+  'SMILES': string,
+  'Synonyms': string
+}

package/src/utils/poly-tool/ui.ts

@@ -4,7 +4,7 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {HELM_POLYMER_TYPE} from '@datagrok-libraries/bio/src/utils/const';
-import {MonomerLibHelper} from '../../utils/monomer-lib';
+import {MonomerLibManager} from '../monomer-lib/lib-manager';
 import {ALL_MONOMERS, CYCLIZATION_TYPE, TRANSFORMATION_TYPE} from './const';
 import {addTransformedColumn} from './transformation';
 import * as rxjs from 'rxjs';
@@ -73,7 +73,7 @@ export function getPolyToolDialog(): DG.Dialog {
     'Type', cyclizationTypes[2], cyclizationTypes, () => { onCyclizationChoice.next(); }
   );
 
-  const monomerLib = MonomerLibHelper.instance.getBioLib();
+  const monomerLib = MonomerLibManager.instance.getBioLib();
   let monomerList1: string[] = [];
   let monomerList2: string[] = [];
   let leftTerminalChoice = ui.choiceInput(

package/src/viewers/vd-regions-viewer.ts

@@ -505,18 +505,19 @@ export class VdRegionsViewer extends DG.JsViewer implements IVdRegionsViewer {
 
   private _onRendered: Subject<void> = new Subject<void>();
 
-  public get onRendered(): Observable<void> { return this._onRendered; }
+  get onRendered(): Observable<void> { return this._onRendered; }
 
-  public invalidate(): void {
-    const logPrefix = `${this.viewerToLog()}.invalidate()`;
+  invalidate(caller?: string): void {
+    const logPrefix = `${this.viewerToLog()}.invalidate(${caller ? ` <- ${caller} ` : ''})`;
     // Put the event trigger in the tail of the synced calls queue.
     this.viewSyncer.sync(`${logPrefix}`, async () => {
       // update view / render
+      // TODO: Request re-render
       this._onRendered.next();
     });
   }
 
-  public async awaitRendered(timeout: number | undefined = 5000): Promise<void> {
+  async awaitRendered(timeout: number | undefined = 5000): Promise<void> {
     await testEvent(this.onRendered, () => {}, () => {
       this.invalidate();
     }, timeout);

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

@@ -1282,18 +1282,19 @@ export class WebLogoViewer extends DG.JsViewer implements IWebLogoViewer {
 
   private _onRendered: Subject<void> = new Subject<void>();
 
-  public get onRendered(): Observable<void> { return this._onRendered; }
+  get onRendered(): Observable<void> { return this._onRendered; }
 
-  public invalidate(): void {
-    const logPrefix = `${this.viewerToLog()}.invalidate()`;
+  invalidate(caller?: string): void {
+    const callLog = `invalidate(${caller ? ` <- ${caller} ` : ''})`;
+    const logPrefix = `${this.viewerToLog()}.${callLog}`;
     // Put the event trigger in the tail of the synced calls queue.
     this.viewSyncer.sync(`${logPrefix}`, async () => {
-      this.invalidate();
+      this.render(WlRenderLevel.None, callLog);
       this._onRendered.next();
     });
   }
 
-  public async awaitRendered(timeout: number | undefined = 5000): Promise<void> {
+  async awaitRendered(timeout: number | undefined = 5000): Promise<void> {
     await testEvent(this.onRendered, () => {}, () => {
       this.invalidate();
     }, timeout);

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

@@ -249,7 +249,10 @@ export class BioSubstructureFilter extends DG.Filter implements IRenderer {
 
   invalidate(caller?: string): void {
     const logPrefix = `${this.filterToLog()}.invalidate(${caller ? ` <- ${caller} ` : ''})`;
-    this.filterSyncer.sync(logPrefix, async () => { this._onRendered.next(); });
+    this.filterSyncer.sync(logPrefix, async () => {
+      // TODO: Request re-render
+      this._onRendered.next();
+    });
   }
 
   async awaitRendered(timeout: number = 10000): Promise<void> {