@datagrok/helm 2.1.34 → 2.2.1

package/src/package-utils.ts

@@ -0,0 +1,150 @@
+import * as ui from 'datagrok-api/ui';
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+
+import * as org from 'org';
+import * as scil from 'scil';
+import * as JSDraw2 from 'JSDraw2';
+import Atom = JSDraw2.Atom;
+
+import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
+import {HelmServiceBase} from '@datagrok-libraries/bio/src/viewers/helm-service';
+import {IMonomerLib, HelmType} from '@datagrok-libraries/bio/src/types';
+import {ILogger} from '@datagrok-libraries/bio/src/utils/logger';
+
+import {HelmService} from './utils/helm-service';
+import {GetMonomerFunc, GetMonomerResType, getWebEditorMonomer} from './utils/get-monomer';
+
+
+type HelmWindowType = Window & {
+  $helmService?: HelmServiceBase,
+}
+declare const window: HelmWindowType;
+
+export function _getHelmService(): HelmServiceBase {
+  let res = window.$helmService;
+  if (!res) res = window.$helmService = new HelmService();
+  return res;
+}
+
+export function initHelmPatchDojo(): void {
+  // patch window.dojox.gfx.svg.Text.prototype.getTextWidth hangs
+  /** get the text width in pixels */
+  // @ts-ignore
+  window.dojox.gfx.svg.Text.prototype.getTextWidth = function() {
+    const rawNode = this.rawNode;
+    const oldParent = rawNode.parentNode;
+    const _measurementNode = rawNode.cloneNode(true);
+    _measurementNode.style.visibility = 'hidden';
+
+    // solution to the "orphan issue" in FF
+    let _width = 0;
+    const _text = _measurementNode.firstChild.nodeValue;
+    oldParent.appendChild(_measurementNode);
+
+    // solution to the "orphan issue" in Opera
+    // (nodeValue == "" hangs firefox)
+    if (_text != '') {
+      let watchdogCounter = 100;
+      while (!_width && --watchdogCounter > 0) { // <-- hangs
+        //Yang: work around svgweb bug 417 -- http://code.google.com/p/svgweb/issues/detail?id=417
+        if (_measurementNode.getBBox)
+          _width = parseInt(_measurementNode.getBBox().width);
+        else
+          _width = 68;
+      }
+    }
+    oldParent.removeChild(_measurementNode);
+    return _width;
+  };
+}
+
+export const helmJsonReplacer = (key: string, value: any): any => {
+  switch (key) {
+  case '_parent': {
+    return `${value.toString()}`;
+  }
+  default:
+    return value;
+  }
+};
+
+export class HelmPackage extends DG.Package {
+  public getMonomerOriginal: GetMonomerFunc;
+  public alertOriginal: (s: string) => void;
+
+  /** Patches Pistoia Monomers.getMonomer method to utilize DG Bio monomer Lib */
+  public initHelmPatchPistoia(monomerLib: IMonomerLib, logger: ILogger): void {
+    const logPrefix: string = 'Helm: initHelmPatchPistoia()';
+    const monomers = org.helm.webeditor.Monomers;
+
+    this.getMonomerOriginal = monomers.getMonomer.bind(monomers);
+    this.logger.debug(`${logPrefix}, this.getMonomerOriginal stored`);
+
+    this.alertOriginal = scil.Utils.alert;
+
+    org.helm.webeditor.Monomers.getMonomer = (
+      a: Atom<HelmType> | HelmType, name: string
+    ): GetMonomerResType => {
+      const logPrefixInt = `${logPrefix}, org.helm.webeditor.Monomers.getMonomer()`;
+      try {
+        // logger.debug(`${logPrefixInt}, a: ${JSON.stringify(a, helmJsonReplacer)}, name: '${name}'`);
+
+        // Creates monomers in lib
+        const dgWem = getWebEditorMonomer(monomerLib, a, name);
+
+        // // Returns null for gap
+        // const oWem = this.getMonomerOriginal(a, name);
+        // if (!oWem)
+        //   logger.warning(`${logPrefixInt}, getMonomerOriginal( a: ${a}, name: ${name}) returns null`);
+        return dgWem; //dgWem;
+      } catch (err) {
+        const [errMsg, errStack] = errInfo(err);
+        logger.error(`${logPrefixInt}, Error: ${errMsg}`, undefined, errStack);
+        throw err;
+      }
+    };
+    scil.Utils.alert = (s: string): void => {
+      logger.warning(`${logPrefix}, scil.Utils.alert() s = 's'.`);
+    };
+
+    // @ts-ignore, intercept with proxy to observe access and usage
+    org.helm.webeditor.Monomers = new class {
+      constructor(base: org.helm.IMonomers) {
+        return new Proxy(base, {
+          get(target: any, p: string | symbol, _receiver: any): any {
+            return target[p];
+          },
+          set(target: any, p: string | symbol, newValue: any, _receiver: any): boolean {
+            if (p != 'sugars' && p != 'linkers' && p != 'bases' && p != 'aas') {
+              const k = 11;
+            }
+            target[p] = newValue;
+            return true;
+          },
+          apply(target: any, thisArg: any, argArray: any[]): any {
+            return target[thisArg](...argArray);
+          },
+        });
+      }
+    }(org.helm.webeditor.Monomers) as org.helm.IMonomers;
+
+    // @ts-ignore, intercept with proxy to observe access and usage
+    org.helm.webeditor = new class {
+      constructor(base: org.helm.IOrgHelmWebEditor) {
+        return new Proxy(base, {
+          get(target: any, p: string | symbol, _receiver: any): any {
+            return target[p];
+          },
+          set(target: any, p: string | symbol, newValue: any, _receiver: any): boolean {
+            target[p] = newValue;
+            return true;
+          },
+          apply(target: any, thisArg: any, argArray: any[]): any {
+            return target[thisArg](...argArray);
+          },
+        });
+      }
+    }(org.helm.webeditor) as org.helm.IOrgHelmWebEditor;
+  }
+}

package/src/package.ts

@@ -3,6 +3,14 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
+// import '@datagrok-libraries/bio/src/types/dojo';
+// import * as dojo from 'DOJO';
+import '@datagrok-libraries/bio/src/types/helm';
+import '@datagrok-libraries/bio/src/types/jsdraw2';
+import * as scil from 'scil';
+import * as org from 'org';
+import * as JSDraw2 from 'JSDraw2';
+
 import $ from 'cash-dom';
 
 import {errorToConsole} from '@datagrok-libraries/utils/src/to-console';
@@ -10,78 +18,61 @@ import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {GapOriginals, SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 import {IMonomerLib, Monomer} from '@datagrok-libraries/bio/src/types';
 import {IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
+import {HelmServiceBase} from '@datagrok-libraries/bio/src/viewers/helm-service';
 
-import {findMonomers, parseHelm} from './utils';
 import {HelmCellRenderer} from './cell-renderer';
 import {HelmHelper} from './helm-helper';
 import {getPropertiesWidget} from './widgets/properties-widget';
+import {HelmGridCellRenderer, HelmGridCellRendererBack} from './utils/helm-grid-cell-renderer';
+import {_getHelmService, HelmPackage, initHelmPatchDojo} from './package-utils';
 
 let monomerLib: IMonomerLib | null = null;
 
-import {WebEditorMonomer, RGROUP_CAP_GROUP_NAME, RGROUP_LABEL, SMILES} from './constants';
-
-export const _package = new DG.Package();
-
-function initHelmPatchDojo(): void {
-  // patch window.dojox.gfx.svg.Text.prototype.getTextWidth hangs
-  /** get the text width in pixels */
-  // @ts-ignore
-  window.dojox.gfx.svg.Text.prototype.getTextWidth = function() {
-    const rawNode = this.rawNode;
-    const oldParent = rawNode.parentNode;
-    const _measurementNode = rawNode.cloneNode(true);
-    _measurementNode.style.visibility = 'hidden';
-
-    // solution to the "orphan issue" in FF
-    let _width = 0;
-    const _text = _measurementNode.firstChild.nodeValue;
-    oldParent.appendChild(_measurementNode);
-
-    // solution to the "orphan issue" in Opera
-    // (nodeValue == "" hangs firefox)
-    if (_text != '') {
-      let watchdogCounter = 100;
-      while (!_width && --watchdogCounter > 0) { // <-- hangs
-        //Yang: work around svgweb bug 417 -- http://code.google.com/p/svgweb/issues/detail?id=417
-        if (_measurementNode.getBBox)
-          _width = parseInt(_measurementNode.getBBox().width);
-        else
-          _width = 68;
-      }
-    }
-    oldParent.removeChild(_measurementNode);
-    return _width;
-  };
-}
+export const _package = new HelmPackage();
 
 //tags: init
 export async function initHelm(): Promise<void> {
-  //@ts-ignore
+  const logPrefix: string = 'Helm: initHelm()';
+  _package.logger.debug(`${logPrefix}, start`);
   org.helm.webeditor.kCaseSensitive = true; // GROK-13880
 
-  return Promise.all([
+  await Promise.all([
     new Promise((resolve, reject) => {
       // @ts-ignore
       dojo.ready(function() { resolve(null); });
     }).then(() => {
       initHelmPatchDojo();
     }),
-    grok.functions.call('Bio:getBioLib'),
+    (async () => {
+      const libHelper = await getMonomerLibHelper();
+      return libHelper.getBioLib();
+    })()
   ])
     .then(([_, lib]: [unknown, IMonomerLib]) => {
+      _package.logger.debug(`${logPrefix}, then(), lib loaded`);
       monomerLib = lib;
       rewriteLibraries(); // initHelm()
+      _package.initHelmPatchPistoia(monomerLib, _package.logger);
+
       monomerLib.onChanged.subscribe((_) => {
         try {
-          rewriteLibraries(); // initHelm()
+          const libSummary = monomerLib!.getSummary();
+          const isLibEmpty = Object.keys(libSummary).length == 0;
+          const libSummaryLog = isLibEmpty ? 'empty' : Object.entries(libSummary)
+            .map(([pt, count]) => `${pt}: ${count}`)
+            .join(', ');
+          const logPrefixInt = `${logPrefix} monomerLib.onChanged()`;
+          _package.logger.debug(`${logPrefixInt}, start, lib: { ${libSummaryLog} }`);
 
-          const monTypeList: string[] = monomerLib!.getPolymerTypes();
-          const msgStr: string = 'Monomer lib updated:<br />' + (
-            monTypeList.length == 0 ? 'empty' : monTypeList.map((monType) => {
-              return `${monType} ${monomerLib!.getMonomerSymbolsByType(monType).length}`;
-            }).join('<br />'));
+          const libSummaryHtml = isLibEmpty ? 'empty' : Object.entries(libSummary)
+            .map(([pt, count]) => `${pt} ${count}`)
+            .join('<br />');
+          const libMsg: string = `Monomer lib updated:<br /> ${libSummaryHtml}`;
+          grok.shell.info(libMsg);
 
-          grok.shell.info(msgStr);
+          _package.logger.debug(`${logPrefixInt}, org,helm.webeditor.Monomers updating ...`);
+          rewriteLibraries(); // initHelm()
+          _package.logger.debug(`${logPrefixInt}, end, org.helm.webeditor.Monomers completed`);
         } catch (err: any) {
           const errMsg = errorToConsole(err);
           console.error('Helm: initHelm monomerLib.onChanged() error:\n' + errMsg);
@@ -96,22 +87,22 @@ export async function initHelm(): Promise<void> {
       errRes.stack = err.stack;
       throw errRes;
     });
+  _package.logger.debug(`${logPrefix}, end`);
 }
 
-export function getMonomerLib(): IMonomerLib {
-  return monomerLib!;
+export function getMonomerLib(): IMonomerLib | null {
+  return monomerLib;
 }
 
 /** Fills org.helm.webeditor.Monomers dictionary for WebEditor */
 function rewriteLibraries() {
-  // @ts-ignore
   org.helm.webeditor.Monomers.clear();
   monomerLib!.getPolymerTypes().forEach((polymerType) => {
     const monomerSymbols = monomerLib!.getMonomerSymbolsByType(polymerType);
     monomerSymbols.forEach((monomerSymbol) => {
       let isBroken = false;
       const monomer: Monomer = monomerLib!.getMonomer(polymerType, monomerSymbol)!;
-      const webEditorMonomer: WebEditorMonomer = {
+      const webEditorMonomer: org.helm.WebEditorMonomer = {
         id: monomerSymbol,
         m: monomer.molfile,
         n: monomer.name,
@@ -123,6 +114,7 @@ function rewriteLibraries() {
       };
 
       if (monomer.rgroups.length > 0) {
+        // @ts-ignore
         webEditorMonomer.rs = monomer.rgroups.length;
         const at: { [prop: string]: any } = {};
         monomer.rgroups.forEach((it) => {
@@ -130,13 +122,13 @@ function rewriteLibraries() {
         });
         webEditorMonomer.at = at;
       } else if (monomer[SMILES] != null) {
+        // @ts-ignore
         webEditorMonomer.rs = Object.keys(getRS(monomer[SMILES].toString())).length;
         webEditorMonomer.at = getRS(monomer[SMILES].toString());
       } else
         isBroken = true;
 
       if (!isBroken) {
-        // @ts-ignore
         org.helm.webeditor.Monomers.addOneMonomer(webEditorMonomer);
       }
     });
@@ -147,29 +139,24 @@ function rewriteLibraries() {
   if (grid) grid.invalidate();
 }
 
+//name: getHelmService
+//output: object result
+export function getHelmService(): HelmServiceBase {
+  return _getHelmService();
+}
+
 //name: helmCellRenderer
 //tags: cellRenderer
 //meta.cellType: helm
 //meta.columnTags: quality=Macromolecule, units=helm
 //output: grid_cell_renderer result
 export function helmCellRenderer(): HelmCellRenderer {
-  return new HelmCellRenderer();
+  // return new HelmCellRenderer(); // old
+  return new HelmGridCellRenderer(); // new
 }
 
 function checkMonomersAndOpenWebEditor(cell: DG.Cell, value?: string, units?: string) {
-  const cellValue: string = !!cell && units === undefined ? cell.value : value;
-  const monomerList: string[] = parseHelm(cellValue);
-  const missedMonomerSet = findMonomers(monomerList);
-  if (missedMonomerSet.size === 0)
-    webEditor(cell, value, units);
-  else if (missedMonomerSet.size === 1 && missedMonomerSet.has(GapOriginals[NOTATION.HELM]))
-    grok.shell.warning(`WebEditor doesn't support Helm with gaps '${GapOriginals[NOTATION.HELM]}'.`);
-  else {
-    grok.shell.warning(
-      `Monomers ${Array.from(missedMonomerSet).map((m) => `'${m}'`).join(', ')} are absent! <br/>` +
-      `Please, upload the monomer library! <br/>` +
-      `<a href="https://datagrok.ai/help/domains/bio/macromolecules" target="_blank">Learn more</a>`);
-  }
+  openWebEditor(cell, value, units);
 }
 
 //tags: cellEditor
@@ -186,7 +173,7 @@ export function editMoleculeCell(cell: DG.GridCell): void {
 //input: string mol { semType: Macromolecule }
 export function openEditor(mol: string): void {
   const df = grok.shell.tv.grid.dataFrame;
-  const col = df.columns.bySemType('Macromolecule')!;
+  const col = df.columns.bySemType('Macromolecule')! as DG.Column<string>;
   const colSh = SeqHandler.forColumn(col);
   const colUnits = col.getTag(DG.TAGS.UNITS);
   if (colUnits === NOTATION.HELM)
@@ -204,17 +191,15 @@ export function propertiesWidget(sequence: DG.SemanticValue): DG.Widget {
   return getPropertiesWidget(sequence);
 }
 
-function webEditor(cell: DG.Cell, value?: string, units?: string) {
+function openWebEditor(cell: DG.Cell, value?: string, units?: string) {
   const view = ui.div();
   // const df = grok.shell.tv.grid.dataFrame;
   // const col = df.columns.bySemType('Macromolecule')!;
-  const col = cell.column;
+  const col = cell.column as DG.Column<string>;
   const sh = SeqHandler.forColumn(col);
   const rowIdx = cell.rowIndex;
-  // @ts-ignore
   org.helm.webeditor.MolViewer.molscale = 0.8;
-  // @ts-ignore
-  const app = new scil.helm.App(view, {
+  const app = new org.helm.webeditor.App(view, {
     showabout: false,
     mexfontsize: '90%',
     mexrnapinontab: true,
@@ -227,12 +212,9 @@ function webEditor(cell: DG.Cell, value?: string, units?: string) {
   const sizes = app.calculateSizes();
   app.canvas.resize(sizes.rightwidth - 100, sizes.topheight - 210);
   let s = {width: sizes.rightwidth - 100 + 'px', height: sizes.bottomheight + 'px'};
-  //@ts-ignore
   scil.apply(app.sequence.style, s);
-  //@ts-ignore
   scil.apply(app.notation.style, s);
   s = {width: sizes.rightwidth + 'px', height: (sizes.bottomheight + app.toolbarheight) + 'px'};
-  //@ts-ignore
   scil.apply(app.properties.parent.style, s);
   app.structureview.resize(sizes.rightwidth, sizes.bottomheight + app.toolbarheight);
   app.mex.resize(sizes.topheight - 80);
@@ -240,9 +222,8 @@ function webEditor(cell: DG.Cell, value?: string, units?: string) {
     if (!!cell && units === undefined)
       app.canvas.helm.setSequence(cell.value, 'HELM');
     else
-      app.canvas.helm.setSequence(value, 'HELM');
+      app.canvas.helm.setSequence(value!, 'HELM');
   }, 200);
-  //@ts-ignore
   ui.dialog({showHeader: false, showFooter: true})
     .add(view)
     .onOK(() => {
@@ -259,30 +240,6 @@ function webEditor(cell: DG.Cell, value?: string, units?: string) {
     }).show({modal: true, fullScreen: true});
 }
 
-function getRS(smiles: string) {
-  const newS = smiles.match(/(?<=\[)[^\][]*(?=])/gm);
-  const res: { [name: string]: string } = {};
-  let el = '';
-  let digit;
-  if (!!newS) {
-    for (let i = 0; i < newS.length; i++) {
-      if (newS[i] != null) {
-        if (/\d/.test(newS[i])) {
-          digit = newS[i][newS[i].length - 1];
-          newS[i] = newS[i].replace(/[0-9]/g, '');
-          for (let j = 0; j < newS[i].length; j++) {
-            if (newS[i][j] != ':')
-              el += newS[i][j];
-          }
-          res['R' + digit] = el;
-          el = '';
-        }
-      }
-    }
-  }
-  return res;
-}
-
 //name: getMolfiles
 //input: column col {semType: Macromolecule}
 //output: column res
@@ -312,3 +269,42 @@ export function getMolfiles(col: DG.Column): DG.Column {
 export async function getHelmHelper(): Promise<IHelmHelper> {
   return HelmHelper.getInstance();
 }
+
+import {testEvent} from '@datagrok-libraries/utils/src/test';
+import {CellRendererBackAsyncBase} from '@datagrok-libraries/bio/src/utils/cell-renderer-async-base';
+import {RGROUP_CAP_GROUP_NAME, RGROUP_LABEL, SMILES} from './constants';
+import {getRS} from './utils/dummy-monomer';
+import {getMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+
+//name: measureCellRenderer
+export async function measureCellRenderer(): Promise<void> {
+  const grid = grok.shell.tv.grid;
+  const gridCol = grid.columns.byName('sequence')!;
+  const back = gridCol.temp['rendererBack'] as HelmGridCellRendererBack;
+
+  let etSum: number = 0;
+  let etCount: number = 0;
+  for (let i = 0; i < 20; ++i) {
+    const t1 = window.performance.now();
+    let t2: number;
+    if (!back.cacheEnabled) {
+      await testEvent(back.onRendered, () => {
+        t2 = window.performance.now();
+        _package.logger.info(`measureCellRenderer() cache disabled , ET: ${t2 - t1} ms`);
+      }, () => {
+        back.invalidate(); // grid.invalidate();
+      }, 5000);
+    } else {
+      await testEvent(grid.onAfterDrawContent, () => {
+        t2 = window.performance.now();
+        _package.logger.info(`measureCellRenderer() cache enabled, ET: ${t2! - t1} ms`);
+      }, () => {
+        grid.invalidate();
+      }, 5000);
+    }
+
+    etSum += (t2! - t1);
+    etCount++;
+  }
+  _package.logger.info(`measureCellRenderer(), avg ET: ${etSum / etCount} ms`);
+}