@datagrok/helm 2.3.2 → 2.3.4

package/package.json

@@ -1,24 +1,24 @@
 {
   "name": "@datagrok/helm",
   "friendlyName": "Helm",
-  "version": "2.3.2",
+  "version": "2.3.4",
   "author": {
     "name": "Oleksandra Serhiienko",
     "email": "oserhiienko@datagrok.ai"
   },
   "description": "Provides support for HELM notation (importing, detecting, rendering, conversion).",
   "sources-backup": [
+    "https://ajax.googleapis.com/ajax/libs/dojo/1.10.4/dojo/dojo.js.uncompressed.js",
     "helm/JSDraw/Scilligence.JSDraw2.Lite-uncompressed.js",
     "helm/JSDraw/Pistoia.HELM-uncompressed.js"
   ],
   "sources": [
-    "https://ajax.googleapis.com/ajax/libs/dojo/1.10.4/dojo/dojo.js.uncompressed.js",
     "css/helm.css"
   ],
   "dependencies": {
-    "@datagrok-libraries/bio": "^5.42.5",
+    "@datagrok-libraries/bio": "^5.42.6",
     "@datagrok-libraries/chem-meta": "^1.2.5",
-    "@datagrok-libraries/utils": "^4.2.13",
+    "@datagrok-libraries/utils": "^4.2.19",
     "cash-dom": "^8.1.1",
     "datagrok-api": "^1.20.0",
     "dayjs": "^1.10.6",

package/src/cell-renderer.ts

@@ -14,7 +14,7 @@ import {HelmMonomerPlacer} from './helm-monomer-placer';
 import {getHoveredMonomerFallback, getHoveredMonomerFromEditorMol} from './utils/get-hovered';
 import {JSDraw2HelmModule} from './types';
 
-import {getMonomerLib} from './package';
+import {_package} from './package';
 
 declare const JSDraw2: JSDraw2HelmModule;
 
@@ -49,6 +49,7 @@ export class HelmCellRenderer extends DG.GridCellRenderer {
       const argsX = e.offsetX - gcb.x;
       const argsY = e.offsetY - gcb.y;
 
+      const monomerLib = _package.monomerLib;
       const editorMol: Mol<HelmType> | null = helmPlacer.getEditorMol(gridCell.tableRowIndex!);
       let seqMonomer: ISeqMonomer | null;
       let missedMonomers: Set<string> = new Set<string>(); // of .size = 0
@@ -57,7 +58,7 @@ export class HelmCellRenderer extends DG.GridCellRenderer {
       else {
         const seq: string = !gridCell.cell.value ? '' : removeGapsFromHelm(gridCell.cell.value as string);
         const monomerList = parseHelm(seq);
-        missedMonomers = findMonomers(monomerList);
+        missedMonomers = findMonomers(monomerList, monomerLib);
         const parsedMonomers = new Set<string>(monomerList);
         seqMonomer = getHoveredMonomerFallback(argsX, argsY, gridCell, helmPlacer);
         if (seqMonomer && !parsedMonomers.has(seqMonomer.symbol)) seqMonomer = null;
@@ -76,7 +77,6 @@ export class HelmCellRenderer extends DG.GridCellRenderer {
       if (seqMonomer) {
         if (!missedMonomers.has(seqMonomer.symbol)) {
           const tooltipElements: HTMLElement[] = [ui.div(seqMonomer.symbol)];
-          const monomerLib = getMonomerLib();
           const monomerDiv = monomerLib ? monomerLib.getTooltip(seqMonomer.polymerType, seqMonomer.symbol) :
             ui.divText('Monomer library is not available.');
           tooltipElements.push(monomerDiv);
@@ -128,7 +128,8 @@ export class HelmCellRenderer extends DG.GridCellRenderer {
       const seq: string = !gridCell.cell.value ? '' : removeGapsFromHelm(gridCell.cell.value);
       const monomerList = parseHelm(seq);
       const monomers: Set<string> = new Set<string>(monomerList);
-      const missedMonomers: Set<string> = findMonomers(monomerList);
+      const monomerLib = _package.monomerLib;
+      const missedMonomers: Set<string> = findMonomers(monomerList, monomerLib);
 
       if (missedMonomers.size == 0) {
         // Recreate host to avoid hanging in window.dojox.gfx.svg.Text.prototype.getTextWidth

package/src/helm-helper.ts

@@ -62,16 +62,16 @@ export class HelmHelper implements IHelmHelper {
       mexfilter: true
     });
     const sizes = webEditorApp.calculateSizes();
-    webEditorApp.canvas.resize(sizes.rightwidth - 100, sizes.topheight - 210);
+    webEditorApp.canvas!.resize(sizes.rightwidth - 100, sizes.topheight - 210);
     let s: Partial<CSSStyleDeclaration> = {width: sizes.rightwidth - 100 + 'px', height: sizes.bottomheight + 'px'};
     scil.apply(webEditorApp.sequence.style, s);
-    scil.apply(webEditorApp.notation.style, s);
+    scil.apply(webEditorApp.notation!.style, s);
     s = {width: sizes.rightwidth + 'px', height: (sizes.bottomheight + webEditorApp.toolbarheight) + 'px'};
-    scil.apply(webEditorApp.properties.parent.style, s);
-    webEditorApp.structureview.resize(sizes.rightwidth, sizes.bottomheight + webEditorApp.toolbarheight);
-    webEditorApp.mex.resize(sizes.topheight - 80);
+    scil.apply(webEditorApp.properties!.parent.style, s);
+    webEditorApp.structureview!.resize(sizes.rightwidth, sizes.bottomheight + webEditorApp.toolbarheight);
+    webEditorApp.mex!.resize(sizes.topheight - 80);
     setTimeout(() => {
-      webEditorApp.canvas.helm.setSequence(helm, 'HELM');
+      webEditorApp.canvas!.helm!.setSequence(helm, 'HELM');
     }, 200);
     return webEditorApp;
   }

package/src/helm-monomer-placer.ts

@@ -10,7 +10,7 @@ import {CellRendererBackBase} from '@datagrok-libraries/bio/src/utils/cell-rende
 
 import {getParts, parseHelm} from './utils';
 
-import {_package, getMonomerLib} from './package';
+import {_package} from './package';
 
 export class HelmMonomerPlacer extends CellRendererBackBase<string> {
   private _allPartsList: (string[] | null)[];

package/src/helm-web-editor.ts

@@ -64,14 +64,14 @@ export function buildWebEditorApp(view: HTMLDivElement): App {
     mexfilter: true
   });
   const sizes = app.calculateSizes();
-  app.canvas.resize(sizes.rightwidth - 100, sizes.topheight - 210);
+  app.canvas!.resize(sizes.rightwidth - 100, sizes.topheight - 210);
   let s = {width: sizes.rightwidth - 100 + 'px', height: sizes.bottomheight + 'px'};
   scil.apply(app.sequence.style, s);
-  scil.apply(app.notation.style, s);
+  scil.apply(app.notation!.style, s);
   s = {width: sizes.rightwidth + 'px', height: (sizes.bottomheight + app.toolbarheight) + 'px'};
-  scil.apply(app.properties.parent.style, s);
-  app.structureview.resize(sizes.rightwidth, sizes.bottomheight + app.toolbarheight);
-  app.mex.resize(sizes.topheight - 80);
+  scil.apply(app.properties!.parent.style, s);
+  app.structureview!.resize(sizes.rightwidth, sizes.bottomheight + app.toolbarheight);
+  app.mex!.resize(sizes.topheight - 80);
 
   return app;
 }

package/src/package-test.ts

@@ -6,7 +6,6 @@ import * as grok from 'datagrok-api/grok';
 // import {HelmType, OrgHelmModuleType} from '@datagrok/helm-web-editor/src/types/org-helm';
 
 import {runTests, tests, TestContext} from '@datagrok-libraries/utils/src/test';
-import {getHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 
 import './tests/_first-tests';
 import './tests/helm-tests';

package/src/package-utils.ts

@@ -2,19 +2,23 @@ import * as ui from 'datagrok-api/ui';
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 
+import {Unsubscribable} from 'rxjs';
+
 import {delay, timeout} from '@datagrok-libraries/utils/src/test';
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
-import type {
-  DojoType, DojoxType, IOrgHelmWebEditor, Monomers
+import {
+  DojoType, DojoxType, HweWindow, IOrgHelmWebEditor, Monomers
 } from '@datagrok-libraries/bio/src/helm/types';
 import {HelmServiceBase} from '@datagrok-libraries/bio/src/viewers/helm-service';
 import {IMonomerLib} from '@datagrok-libraries/bio/src/types';
 import {LoggerWrapper} from '@datagrok-libraries/bio/src/utils/logger';
-import {IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import {errorToConsole} from '@datagrok-libraries/utils/src/to-console';
 
 import {HelmHelper} from './helm-helper';
 import {HelmService} from './utils/helm-service';
 import {OrgHelmModule, ScilModule} from './types';
+import {rewriteLibraries} from './utils/get-monomer';
 
 import {_package} from './package';
 
@@ -23,13 +27,17 @@ declare const dojox: DojoxType;
 declare const scil: ScilModule;
 declare const org: OrgHelmModule;
 
-// eslint-disable-next-line
-var dojoConfig = {async: true};
-
-type HelmWindowType = Window & {
+type DojoConfigWindowType = {
+  dojoConfig: {
+    packages?: (string | { name: string, location: string })[],
+    deps?: string[], callback: Function, has?: any, parseOnLoad?: boolean, async?: boolean | string, locale?: string,
+  };
+};
+type HelmWindowType = {
   $helmService?: HelmServiceBase,
-}
-declare const window: HelmWindowType;
+  require: Function,
+};
+declare const window: Window & DojoConfigWindowType & HweWindow & HelmWindowType;
 
 export function _getHelmService(): HelmServiceBase {
   let res = window.$helmService;
@@ -41,66 +49,124 @@ export async function initHelmLoadAndPatchDojo(): Promise<void> {
   const logPrefix = `Helm: _package.initHelmPatchDojo()`;
   // patch window.dojox.gfx.svg.Text.prototype.getTextWidth hangs
   /** get the text width in pixels */
-  // @ts-ignore
-  await timeout(async () => {
-    const dojoTargetList: { module: string, checker: () => boolean }[] = [
-      {module: 'dojo.ready', checker: () => !!dojo?.ready},
-      {module: 'dojo.window', checker: () => !!dojo?.window},
-      {module: 'dojo.io.script', checker: () => !!dojo?.io?.script},
-      // {module: 'dojo.request.iframe', checker: () => !!dojo?.request?.iframe},
-      {module: 'dojo.dom', checker: () => !!dojo?.dom},
-      {module: 'dojox.gfx', checker: () => !!dojox?.gfx},
-      {module: 'dojox.gfx.svg', checker: () => !!dojox?.gfx?.svg && !!dojox?.gfx?.createSurface},
-      {module: 'dojox.gfx.shape', checker: () => !!dojox?.gfx?.shape},
-      // {module: 'dojox.storage.Provider', checker: () => !!dojox?.storage?.Provider},
-      // {module: 'dojox.storage.LocalStorageProvider', checker: () => !!dojox?.storage?.LocalStorageProvider},
+  const pi = DG.TaskBarProgressIndicator.create('Loading Helm Web Editor ...');
+  try {
+    await delay(2000);
+    const requireBackup = window.require;
+
+    // dojo.window','dojo.io.script','dojo.io.iframe','dojo.dom','dojox.gfx','dojox.gfx.svg','dojox.gfx.shape','dojox.charting'
+    const dojoTargetList: { name: string, checker: () => boolean }[] = [
+      {name: 'dojo.window', checker: () => !!dojo?.window},
+      {name: 'dojo.ready', checker: () => !!dojo?.ready},
+      {name: 'dojo.io.script', checker: () => !!dojo?.io?.script},
+      {name: 'dojo.io.iframe', checker: () => !!dojo?.io?.iframe},
+      // {name: 'dojo.dom', checker: () => !!dojo?.dom},
+      {name: 'dojox.gfx', checker: () => !!dojox?.gfx},
+      {name: 'dojox.gfx.svg', checker: () => !!dojox?.gfx?.svg},
+      {name: 'dojox.gfx.createSurface', checker: () => !!dojox?.gfx?.createSurface},
+      {name: 'dojox.gfx.shape', checker: () => !!dojox?.gfx?.shape},
+      {name: 'dojox.storage.Provider', checker: () => !!dojox?.storage?.Provider},
+      {name: 'dojox.storage.LocalStorageProvider', checker: () => !!dojox?.storage?.LocalStorageProvider},
+      // {name: 'dojox.charting', checker: () => !!dojox.charting},
+      // {name: 'dojox.charting.themes.Claro', checker: () => !!dojox.charting?.themes?.Claro},
+      // {name: 'dojox.charting.themes.Wetland', checker: () => !!dojox.charting?.themes?.Wetland},
+      // {name: 'dojox.charting.plot2d.Base', checker: () => !!dojox.charting?.plot2d?.Base},
+      // {name: 'dojox.charting.Series', checker: () => !!dojox?.charting?.Series},
+      // {name: 'dojox.charting.Chart2D', checker: () => !!dojox?.charting?.Chart2D},
     ];
-    for (const dojoTarget of dojoTargetList) {
-      try { dojo.require(dojoTarget.module); } catch (err: any) {
-        _package.logger.error(err.message);
-      }
-    }
-    const getDojoProgress = (): string[] => {
-      return dojoTargetList.filter((dt) => !dt.checker()).map((dt) => dt.module);
+    /** Gets list ofd modules not ready yet */
+    const getDojoNotReadyList = (): string[] => {
+      return dojoTargetList.filter((dt) => !dt.checker()).map((dt) => dt.name);
     };
-    /** List of dojo modules not ready yet */ let dojoProgress: string[];
-    while ((dojoProgress = getDojoProgress()).length > 0) {
-      _package.logger.debug(`${logPrefix}, dojo loading ... ${dojoProgress.map((m) => `'${m}'`).join(',')} ...`);
-      await delay(100);
+
+    try {
+      await timeout(async () => {
+
+        await new Promise<void>((resolve, reject) => {
+          window.dojoConfig = {
+            callback: () => { resolve(); },
+            parseOnLoad: true,
+            async: false,
+            locale: 'en-us', // to limit dijit/nls file set
+          };
+          // Load dojo without package/sources section for the settings dojoConfig to take effect
+          DG.Utils.loadJsCss([
+            // 'https://ajax.googleapis.com/ajax/libs/dojo/1.10.4/dojo/dojo.js.uncompressed.js',
+            `${_package.webRoot}/vendor/dojo-1.10.10/dojo/dojo.js.uncompressed.js`,
+          ]).then(() => {});
+        });
+
+        const dojoRequire = window.require;
+        const cmp = dojoRequire == requireBackup;
+        try {
+          await new Promise<void>((resolve, reject) => {
+            dojoRequire(['dojo/window', 'dojo/dom', 'dojo/io/script', 'dojo/io/iframe',
+                'dojox/gfx', 'dojox/gfx/svg', 'dojox/gfx/shape',
+                'dojox/storage/Provider', 'dojox/storage/LocalStorageProvider',
+                'dijit/_base', 'dijit/Tooltip', 'dijit/form/_FormValueWidget',
+                'dijit/form/DropDownButton', 'dijit/layout/AccordionContainer', 'dijit/form/ComboButton',
+                'dijit/layout/StackController', 'dijit/layout/StackContainer',
+              ],
+              (...args: any[]) => {
+                resolve();
+              });
+          });
+        } finally {
+          // TODO: Check interference with NGL
+          window.require = function(...args: any[]) {
+            _package.logger.debug(`${logPrefix}, window.require( ${JSON.stringify(args)} )`);
+            dojoRequire(...args);
+          };
+        }
+
+        /** List of dojo modules not ready yet */ let dojoNotReadyList: string[];
+        while ((dojoNotReadyList = getDojoNotReadyList()).length > 0) {
+          const dojoProgress = dojoTargetList.length - dojoNotReadyList.length;
+          pi.update(Math.round(100 * dojoProgress / dojoTargetList.length),
+            `Loading Helm Web Editor ${dojoProgress}/${dojoTargetList.length}`);
+          _package.logger.debug(`${logPrefix}, dojo loading ... ${dojoNotReadyList.map((m) => `'${m}'`).join(',')} ...`);
+          await delay(100);
+        }
+        _package.logger.debug(`${logPrefix}, dojo ready all modules`);
+      }, 60000, 'timeout dojox.gfx.svg');
+    } catch (err: any) {
+      const dojoNotReadyList = getDojoNotReadyList();
+      _package.logger.error(`${logPrefix}, dojo not ready ${dojoNotReadyList.map((m) => `'${m}'`).join(',')} ...`);
     }
-    _package.logger.debug(`${logPrefix}, dojo ready all modules`);
-  }, 60000, 'timeout dojox.gfx.svg');
-
-  _package.logger.debug(`${logPrefix}, patch window.dojox.gfx.svg.Text.prototype.getTextWidth`);
-  // @ts-ignore
-  window.dojox.gfx.svg.Text.prototype.getTextWidth = function() {
-    // Patched via Datagrok Helm package
-    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;
+
+    _package.logger.debug(`${logPrefix}, patch window.dojox.gfx.svg.Text.prototype.getTextWidth`);
+    // @ts-ignore
+    window.dojox.gfx.svg.Text.prototype.getTextWidth = function() {
+      // Patched via Datagrok Helm package
+      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;
-  };
-  _package.logger.debug(`${logPrefix}, end`);
+      oldParent.removeChild(_measurementNode);
+      return _width;
+    };
+    _package.logger.debug(`${logPrefix}, end`);
+  } finally {
+    pi.close();
+  }
 }
 
 export const helmJsonReplacer = (key: string, value: any): any => {
@@ -126,8 +192,31 @@ export class HelmPackage extends DG.Package {
     this.helmHelper = new HelmHelper(this.logger);
   }
 
-  setLibHelper(libHelper: IMonomerLibHelper) {
-    this.libHelper = libHelper;
+  // -- Init --
+  /** Loads Dojo and HelmWebEditor, waits for init, patches */
+  async initHELMWebEditor(): Promise<void> {
+    const logPrefix: string = 'Helm: Package.initDojo()';
+
+    _package.logger.debug(`${logPrefix}, dependence loading …`);
+    const t1: number = performance.now();
+
+    _package.logger.debug(`${logPrefix}, dojox loading and patching …`);
+    await initHelmLoadAndPatchDojo();
+    _package.logger.debug(`${logPrefix}, dojox loaded and patched`);
+
+    // Alternatively load old bundles by package.json/sources
+    _package.logger.debug(`${logPrefix}, HelmWebEditor awaiting …`);
+    require('../node_modules/@datagrok-libraries/helm-web-editor/dist/package.js');
+    await window.helmWebEditor$.initPromise;
+    _package.logger.debug(`${logPrefix}, HelmWebEditor loaded`);
+
+    org.helm.webeditor.kCaseSensitive = true; // GROK-13880
+
+    _package.logger.debug(`${logPrefix}, scil.Utils.alert patch`);
+    _package.initHelmPatchScilAlert(); // patch immediately
+
+    const t2: number = performance.now();
+    _package.logger.debug(`${logPrefix}, dependence loaded, ET: ${(t2 - t1)} ms`);
   }
 
   public initHelmPatchScilAlert(): void {
@@ -139,13 +228,13 @@ export class HelmPackage extends DG.Package {
   }
 
   /** Patches Pistoia Monomers.getMonomer method to utilize DG Bio monomer Lib */
-  public async initHelmPatchPistoia(monomerLib: IMonomerLib): Promise<void> {
+  public initHelmPatchPistoia(): void {
     const logPrefix: string = 'Helm: initHelmPatchPistoia()';
     const monomers = org.helm.webeditor.Monomers;
 
     this.logger.debug(`${logPrefix}, this.getMonomerOriginal stored`);
 
-    this.helmHelper.overrideGetMonomer(this.helmHelper.buildGetMonomerFromLib(monomerLib));
+    this.helmHelper.overrideGetMonomer(this.helmHelper.buildGetMonomerFromLib(this.monomerLib));
 
     // @ts-ignore, intercept with proxy to observe access and usage
     org.helm.webeditor.Monomers = new class {
@@ -186,4 +275,57 @@ export class HelmPackage extends DG.Package {
       }
     }(org.helm.webeditor) as IOrgHelmWebEditor;
   }
+
+  // -- MonomerLib --
+
+  public get monomerLib(): IMonomerLib {
+    if (!this.libHelper)
+      throw new Error(`Helm: _package.libHelper is not initialized yet`);
+    return this.libHelper.getBioLib();
+  }
+
+  private _monomerLibSub: Unsubscribable;
+
+  async initMonomerLibHelper(): Promise<void> {
+    if (!!this.libHelper)
+      throw new Error(`Helm: _package.libHelper is initialized already`);
+
+    this.libHelper = await getMonomerLibHelper();
+  }
+
+  /** Requires both Bio & HELMWebEditor initialized */
+  async initMonomerLib(): Promise<void> {
+    const lib = this.monomerLib;
+    rewriteLibraries(lib); // initHelm()
+    this._monomerLibSub = lib.onChanged
+      .subscribe(this.monomerLibOnChangedHandler.bind(this));
+
+    this.initHelmPatchPistoia();
+  }
+
+  monomerLibOnChangedHandler(): void {
+    const logPrefix = `Helm: _package.monomerLibOnChangedHandler()`;
+    try {
+      const libSummary = this.monomerLib.getSummaryObj();
+      const isLibEmpty = Object.keys(libSummary).length == 0;
+      const libSummaryLog = isLibEmpty ? 'empty' : Object.entries(libSummary)
+        .map(([pt, count]) => `${pt}: ${count}`)
+        .join(', ');
+      _package.logger.debug(`${logPrefix}, start, lib: { ${libSummaryLog} }`);
+
+      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);
+
+      _package.logger.debug(`${logPrefix}, org,helm.webeditor.Monomers updating ...`);
+      rewriteLibraries(this.monomerLib); // initHelm() monomerLib.onChanged()
+      _package.logger.debug(`${logPrefix}, end, org.helm.webeditor.Monomers completed`);
+    } catch (err: any) {
+      const errMsg = errorToConsole(err);
+      console.error(`${logPrefix} error:\n` + errMsg);
+      // throw err; // Prevent disabling event handler
+    }
+  }
 }

package/src/package.ts

@@ -28,7 +28,7 @@ import {getRS} from './utils/get-monomer-dummy';
 import {buildWebEditorApp} from './helm-web-editor';
 import {JSDraw2HelmModule, OrgHelmModule, ScilModule} from './types';
 
-export const _package = new HelmPackage({debug: false});
+export const _package = new HelmPackage(/*{debug: true}/**/);
 
 let monomerLib: IMonomerLib | null = null;
 
@@ -51,71 +51,14 @@ export async function initHelm(): Promise<void> {
   _package.logger.debug(`${logPrefix}, start`);
 
   try {
-    const [_, lib]: [void, IMonomerLib] = await Promise.all([
-      Promise.all([
-        (async () => {
-          _package.logger.debug(`${logPrefix}, dependence loading …`);
-          const t1: number = performance.now();
-
-          _package.logger.debug(`${logPrefix}, dojox loading and patching …`);
-          await initHelmLoadAndPatchDojo();
-          _package.logger.debug(`${logPrefix}, dojox loaded and patched`);
-
-          // Alternatively load old bundles by package.json/sources
-          _package.logger.debug(`${logPrefix}, HelmWebEditor awaiting …`);
-          require('../node_modules/@datagrok-libraries/helm-web-editor/dist/package.js');
-          await window.helmWebEditor$.initPromise;
-          _package.logger.debug(`${logPrefix}, HelmWebEditor loaded`);
-
-          org.helm.webeditor.kCaseSensitive = true; // GROK-13880
-
-          _package.logger.debug(`${logPrefix}, scil.Utils.alert patch`);
-          _package.initHelmPatchScilAlert(); // patch immediately
-
-          const t2: number = performance.now();
-          _package.logger.debug(`${logPrefix}, dependence loaded, ET: ${(t2 - t1)} ms`);
-        })()
-      ]).then(() => {
-
-        // settings
-      }),
-      (async () => {
-        const libHelper = await getMonomerLibHelper();
-        _package.setLibHelper(libHelper);
-        return libHelper.getBioLib();
-      })()
-    ]);
+    await Promise.all([
+      _package.initHELMWebEditor(),
+      _package.initMonomerLibHelper(),
+    ]).then(() => {
+      _package.initMonomerLib();
+    });
 
     _package.logger.debug(`${logPrefix}, then(), lib loaded`);
-    monomerLib = lib;
-    // rewriteLibraries(); // initHelm()
-    await _package.initHelmPatchPistoia(monomerLib);
-
-    monomerLib.onChanged.subscribe((_) => {
-      const logPrefixInt = `${logPrefix} monomerLib.onChanged()`;
-      try {
-        const libSummary = monomerLib!.getSummaryObj();
-        const isLibEmpty = Object.keys(libSummary).length == 0;
-        const libSummaryLog = isLibEmpty ? 'empty' : Object.entries(libSummary)
-          .map(([pt, count]) => `${pt}: ${count}`)
-          .join(', ');
-        _package.logger.debug(`${logPrefixInt}, start, lib: { ${libSummaryLog} }`);
-
-        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);
-
-        // _package.logger.debug(`${logPrefixInt}, org,helm.webeditor.Monomers updating ...`);
-        // rewriteLibraries(); // initHelm() monomerLib.onChanged()
-        // _package.logger.debug(`${logPrefixInt}, end, org.helm.webeditor.Monomers completed`);
-      } catch (err: any) {
-        const errMsg = errorToConsole(err);
-        console.error(`${logPrefixInt} error:\n` + errMsg);
-        // throw err; // Prevent disabling event handler
-      }
-    });
   } catch (err: any) {
     const [errMsg, errStack] = errInfo(err);
     // const errMsg: string = err instanceof Error ? err.message : !!err ? err.toString() : 'Exception \'undefined\'';
@@ -129,10 +72,6 @@ export async function initHelm(): Promise<void> {
   _package.logger.debug(`${logPrefix}, end`);
 }
 
-export function getMonomerLib(): IMonomerLib | null {
-  return monomerLib;
-}
-
 //name: getHelmService
 //output: object result
 export function getHelmService(): HelmServiceBase {
@@ -198,14 +137,14 @@ function openWebEditor(cell: DG.Cell, value?: string, units?: string) {
   setTimeout(async () => {
     app = await buildWebEditorApp(view);
     if (!!cell && units === undefined)
-      app.canvas.helm.setSequence(cell.value, 'HELM');
+      app.canvas!.helm!.setSequence(cell.value, 'HELM');
     else
-      app.canvas.helm.setSequence(value!, 'HELM');
+      app.canvas!.helm!.setSequence(value!, 'HELM');
   }, 20);
   const dlg = ui.dialog({showHeader: false, showFooter: true});
   dlg.add(view)
     .onOK(() => {
-      const helmValue: string = app.canvas.getHelm(true).replace(/<\/span>/g, '')
+      const helmValue: string = app.canvas!.getHelm(true).replace(/<\/span>/g, '')
         .replace(/<span style='background:#bbf;'>/g, '');
       if (!!cell) {
         if (units === undefined)

package/src/tests/findMonomers-tests.ts

@@ -53,8 +53,9 @@ category('findMonomers', () => {
   }
 
   function _testFindMonomers(testHelmValue: string, tgtMissedSet: Set<string>): void {
+    const monomerLib = monomerLibHelper.getBioLib();
     const monomerSymbolList: string[] = parseHelm(testHelmValue);
-    const resMissedSet: Set<string> = findMonomers(monomerSymbolList);
+    const resMissedSet: Set<string> = findMonomers(monomerSymbolList, monomerLib);
     expectObject(resMissedSet, tgtMissedSet);
   }
 });