@datagrok/helm 2.3.2 → 2.3.3

package/package.json

@@ -1,24 +1,24 @@
 {
   "name": "@datagrok/helm",
   "friendlyName": "Helm",
-  "version": "2.3.2",
+  "version": "2.3.3",
   "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
+  };
+};
+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,136 @@ 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},
-    ];
-    for (const dojoTarget of dojoTargetList) {
-      try { dojo.require(dojoTarget.module); } catch (err: any) {
-        _package.logger.error(err.message);
+  const pi = DG.TaskBarProgressIndicator.create('Loading Helm Web Editor ...');
+  try {
+    await delay(2000);
+    const requireBackup = window.require;
+
+    await timeout(async () => {
+
+      await new Promise<void>((resolve, reject) => {
+        window.dojoConfig = {
+          deps: [
+            // 'dojo/dom', 'dojo/window', 'dojo/io/script', 'dojo/io/iframe',
+            // 'dojox/storage/LocalStorageProvider',
+            // 'dijit/layout/ContentPane',
+          ],
+          // packages: [
+          //   'dojo.ready', 'dojo.window', 'dojo.io.script', 'dojo.io.iframe', 'dojo.dom',
+          //   'dojox.gfx', 'dojox.gfx.shape',
+          // ],
+          callback: () => { resolve(); },
+          // has: {
+          //   "dojo-firebug": true,
+          //   "dojo-debug-messages": true,
+          // },
+          parseOnLoad: true,
+          async: false
+        };
+        // 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',
+              '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 {
+        window.require = function(...args: any[]) {
+          _package.logger.debug(`${logPrefix}, window.require( ${JSON.stringify(args)} )`);
+          dojoRequire(...args);
+        };
       }
-    }
-    const getDojoProgress = (): string[] => {
-      return dojoTargetList.filter((dt) => !dt.checker()).map((dt) => dt.module);
-    };
-    /** 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);
-    }
-    _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;
+
+      //await delay(50);
+
+      // dojo.window','dojo.io.script','dojo.io.iframe','dojo.dom','dojox.gfx','dojox.gfx.svg','dojox.gfx.shape','dojox.charting'
+      const dojoTargetList: { name: string, module: string | null, checker: () => boolean }[] = [
+        {name: 'dojo.window', module: null, checker: () => !!dojo?.window},
+        {name: 'dojo.ready', module: null, checker: () => !!dojo?.ready},
+        {name: 'dojo.io.script', module: null, checker: () => !!dojo?.io?.script},
+        {name: 'dojo.io.iframe', module: null, checker: () => !!dojo?.io?.iframe},
+        // //{name: 'dojo.request.script', module: 'dojo.request.script', checker: () => !!dojo?.request?.iframe},
+        // {name: 'dojo.dom', module: 'dojo.dom', checker: () => !!dojo?.dom},
+        // {name: 'dojox.gfx', module: 'dojox.gfx', checker: () => !!dojox?.gfx},
+        // {name: 'dojox.gfx.svg', module: 'dojox.gfx.svg', checker: () => !!dojox?.gfx?.svg},
+        {name: 'dojox.gfx.createSurface', module: null, checker: () => !!dojox?.gfx?.createSurface},
+        // {name: 'dojox.gfx.shape', module: 'dojox.gfx.shape', checker: () => !!dojox?.gfx?.shape},
+        // {name: 'dojox.charting.themes.Claro', module: 'dojox.charting.themes.Claro', checker: () => !!dojox.charting?.themes?.Claro},
+        // {name: 'dojox.charting.themes.Wetland', module: 'dojox.charting.themes.Wetland', checker: () => !!dojox.charting?.themes?.Wetland},
+        // {name: 'dojox.charting.plot2d.Base', module: 'dojox.charting.plot2d.Base', checker: () => !!dojox.charting?.plot2d?.Base},
+        // {name: 'dojox.charting.Series', module: 'dojox.charting.Series', checker: () => !!dojox?.charting?.Series},
+        // {name: 'dojox.charting.Chart2D', module: 'dojox.charting.Chart2D', checker: () => !!dojox?.charting?.Chart2D},
+        // //{module: 'dojox.charting', checker: () => !!dojox.charting},
+        // // {module: 'dojox.storage.Provider', checker: () => !!dojox?.storage?.Provider},
+        // // {module: 'dojox.storage.LocalStorageProvider', checker: () => !!dojox?.storage?.LocalStorageProvider},
+      ];
+      for (const dojoTarget of dojoTargetList) {
+        try { if (dojoTarget.module) dojo.require(dojoTarget.module); } catch (err: any) {
+          _package.logger.error(err.message);
+        }
       }
-    }
-    oldParent.removeChild(_measurementNode);
-    return _width;
-  };
-  _package.logger.debug(`${logPrefix}, end`);
+      /** 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 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');
+
+    _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`);
+  } finally {
+    pi.close();
+  }
 }
 
 export const helmJsonReplacer = (key: string, value: any): any => {
@@ -130,6 +208,39 @@ export class HelmPackage extends DG.Package {
     this.libHelper = libHelper;
   }
 
+  // -- Init --
+  /** Loads Dojo and HelmWebEditor, waits for init, patches */
+  async initHelm(): 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`);
+  }
+
+  async getMonomerLib(): Promise<IMonomerLib> {
+    const libHelper = await getMonomerLibHelper();
+    _package.setLibHelper(libHelper);
+    return libHelper.getBioLib();
+  }
+
   public initHelmPatchScilAlert(): void {
     const logPrefix: string = 'Helm: initHelmPatchScilAlert()';
     this.alertOriginal = scil.Utils.alert;
@@ -139,13 +250,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 +297,52 @@ export class HelmPackage extends DG.Package {
       }
     }(org.helm.webeditor) as IOrgHelmWebEditor;
   }
+
+  // -- MonomerLib --
+
+  private _monomerLib: IMonomerLib;
+  public get monomerLib(): IMonomerLib {
+    if (!this._monomerLib)
+      throw new Error(`Helm: _package._monomerLib is not initialized yet`);
+    return this._monomerLib;
+  }
+
+  private _monomerLibSub: Unsubscribable;
+
+  initMonomerLib(lib: IMonomerLib) {
+    if (!!this._monomerLib)
+      throw new Error(`Helm: _package._monomerLib is initialized already`);
+    this._monomerLib = lib;
+    rewriteLibraries(this._monomerLib); // initHelm()
+    this._monomerLibSub = this._monomerLib.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;
 
@@ -52,70 +52,12 @@ export async function initHelm(): Promise<void> {
 
   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();
-      })()
+      _package.initHelm(),
+      _package.getMonomerLib(),
     ]);
 
     _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
-      }
-    });
+    _package.initMonomerLib(lib);
   } catch (err: any) {
     const [errMsg, errStack] = errInfo(err);
     // const errMsg: string = err instanceof Error ? err.message : !!err ? err.toString() : 'Exception \'undefined\'';
@@ -129,10 +71,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 +136,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);
   }
 });