@datagrok/helm 2.2.0 → 2.3.0

package/src/tests/properties-widget-tests.ts

@@ -2,15 +2,17 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
 
-import {after, before, category, expect, expectObject, test} from '@datagrok-libraries/utils/src/test';
+import {after, before, category, expect, expectObject, test, timeout} from '@datagrok-libraries/utils/src/test';
 import {ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 import {
   getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import {generateLongSequence} from '@datagrok-libraries/bio/src/utils/generator';
 
-import {getPropertiesDict} from '../widgets/properties-widget';
+import {initHelmMainPackage} from './utils';
+import {getPropertiesDict, SeqPropertiesError} from '../widgets/properties-widget';
 
 const enum MolProps {
   formula = 'formula',
@@ -25,6 +27,7 @@ const enum Tests {
   separatorGaps = 'separator-gaps',
   fastaPt = 'fasta-PT',
   fastaPtMsa = 'fasta-PT-MSA',
+  fastaRna = 'fasta-RNA',
   fastaDna = 'fasta-DNA',
 }
 
@@ -56,6 +59,11 @@ const TestsData: {
     units: NOTATION.FASTA, alphabet: ALPHABET.PT,
     res: {[MolProps.formula]: 'C38H58N10O12S', [MolProps.mw]: 878.99, [MolProps.extinctCoef]: 1.55}
   },
+  [Tests.fastaRna]: {
+    seq: 'ACGUAUUCC',
+    units: NOTATION.FASTA, alphabet: ALPHABET.RNA,
+    res: {[MolProps.formula]: 'C84H107N30O65P9', [MolProps.mw]: 2855.67, [MolProps.extinctCoef]: 96.27}
+  },
   [Tests.fastaDna]: {
     seq: 'ACGTATTCC',
     units: NOTATION.FASTA, alphabet: ALPHABET.DNA,
@@ -69,9 +77,14 @@ category('properties-widget', () => {
   let userLibSettings: any = null;
 
   before(async () => {
+    await initHelmMainPackage();
+
     monomerLibHelper = await getMonomerLibHelper();
     userLibSettings = getUserLibSettings();
+
     await setUserLibSettingsForTests();
+    await timeout(async () => { await monomerLibHelper.awaitLoaded(); },
+      5000, 'MonomerLibHelper.awaitLoaded() timeout');
     await monomerLibHelper.loadLibraries(true); // load default libraries
   });
 
@@ -85,6 +98,22 @@ category('properties-widget', () => {
       testPropertiesDict(testData.seq, testData.units, testData.separator, testData.alphabet, testData.res);
     });
   }
+
+  test('too-long', async () => {
+    const colList = generateLongSequence();
+    const df = DG.DataFrame.fromColumns(colList);
+    const col = df.getCol('MSA');
+
+    const sh = SeqHandler.forColumn(col);
+    let errCatched = true;
+    try {
+      const _actPropDict = getPropertiesDict(col.get(0), sh);
+      const k = 11;
+    } catch (err: any) {
+      if (err instanceof SeqPropertiesError) errCatched = true;
+    }
+    expect(errCatched, true);
+  });
 });
 
 function testPropertiesDict(
@@ -95,7 +124,7 @@ function testPropertiesDict(
   col.setTag(DG.TAGS.UNITS, units);
   if (separator) col.setTag(bioTAGS.separator, separator);
   if (alphabet) col.setTag(bioTAGS.alphabet, alphabet);
-  const uh = SeqHandler.forColumn(col);
-  const actPropDict = getPropertiesDict(seq, uh);
+  const sh = SeqHandler.forColumn(col);
+  const actPropDict = getPropertiesDict(seq, sh);
   expectObject(actPropDict, expPropDict);
 }

package/src/tests/renderers-tests.ts

@@ -15,7 +15,7 @@ import {
   getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 
-import {awaitGrid} from './utils';
+import {awaitGrid, initHelmMainPackage} from './utils';
 import {TAGS as helmTAGS} from '../constants';
 
 import {_package} from '../package-test';
@@ -26,6 +26,8 @@ category('renderers', () => {
   let userLibSettings: UserLibSettings;
 
   before(async () => {
+    await initHelmMainPackage();
+
     monomerLibHelper = await getMonomerLibHelper();
     userLibSettings = await getUserLibSettings();
 

package/src/tests/utils.ts

@@ -3,6 +3,12 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {delay, testEvent} from '@datagrok-libraries/utils/src/test';
+import {getHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
+
+
+export async function initHelmMainPackage(): Promise<void> {
+  await getHelmHelper();
+}
 
 export async function awaitGrid(grid: DG.Grid, timeout: number = 5000): Promise<void> {
   await delay(100);

package/src/types/index.ts

@@ -0,0 +1,5 @@
+import {HelmType, JSDraw2ModuleType, OrgType, ScilModuleType} from '@datagrok-libraries/bio/src/helm/types';
+
+export type ScilModule = ScilModuleType;
+export type JSDraw2HelmModule = JSDraw2ModuleType<HelmType>;
+export type OrgHelmModule = OrgType;

package/src/utils/get-hovered.ts

@@ -2,15 +2,14 @@ import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 import * as ui from 'datagrok-api/ui';
 
-import * as org from 'org';
-import * as JSDraw2 from 'JSDraw2';
+import {HelmType, PolymerType, Atom, Mol} from '@datagrok-libraries/bio/src/helm/types';
 
-import {IMonomerLib} from '@datagrok-libraries/bio/src/types/index';
+import {helmTypeToPolymerType} from '@datagrok-libraries/bio/src/monomer-works/monomer-works';
 
 import {HelmMonomerPlacer, ISeqMonomer} from '../helm-monomer-placer';
 
 export function getHoveredMonomerFromEditorMol(
-  argsX: number, argsY: number, gridCell: DG.GridCell, mol: JSDraw2.IEditorMol
+  argsX: number, argsY: number, gridCell: DG.GridCell, mol: Mol<HelmType>
 ): ISeqMonomer | null {
   let hoveredSeqMonomer: ISeqMonomer | null = null;
 
@@ -80,32 +79,21 @@ export function getHoveredMonomerFallback(
   }
   left = (argsX >= sumLengths[left]) ? left : left - 1; // correct left to between sumLengths
   if (left >= 0)
-    hoveredSeqMonomer = getSeqMonomerFromHelm(allParts[0], allParts[left], helmPlacer.monomerLib);
+    hoveredSeqMonomer = getSeqMonomerFromHelm(allParts[0], allParts[left]);
   return hoveredSeqMonomer;
 }
 
-function getSeqMonomerFromHelmAtom(atom: JSDraw2.IEditorMolAtom): ISeqMonomer {
-  let polymerType: string | undefined = undefined;
-  switch (atom.bio.type) {
-  case 'HELM_BASE':
-  case 'HELM_SUGAR': // r - ribose, d - deoxyribose
-  case 'HELM_LINKER': // p - phosphate
-    polymerType = 'RNA';
-    break;
-  case 'HELM_AA':
-    polymerType = 'PEPTIDE';
-    break;
-  default:
-    polymerType = 'PEPTIDE';
-  }
+function getSeqMonomerFromHelmAtom(atom: Atom<HelmType>): ISeqMonomer {
+  const polymerType = helmTypeToPolymerType(atom.bio.type);
   return {symbol: atom.elem, polymerType: polymerType};
 }
 
 function getSeqMonomerFromHelm(
-  helmPrefix: string, symbol: string, monomerLib: IMonomerLib
+  helmPrefix: string, symbol: string
 ): ISeqMonomer {
   let resSeqMonomer: ISeqMonomer | undefined = undefined;
-  for (const polymerType of monomerLib.getPolymerTypes()) {
+  const polymerTypeList: PolymerType[] = ['RNA', 'PEPTIDE', 'CHEM', 'BLOB', 'G'];
+  for (const polymerType of polymerTypeList) {
     if (helmPrefix.startsWith(polymerType))
       resSeqMonomer = {symbol: symbol, polymerType: polymerType};
   }

package/src/utils/get-monomer-dummy.ts

@@ -0,0 +1,149 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {
+  HelmType, IWebEditorMonomer, MonomerType, PolymerType, WebEditorRGroups
+} from '@datagrok-libraries/bio/src/helm/types';
+
+import {Monomer} from '@datagrok-libraries/bio/src/types/index';
+import {
+  HELM_REQUIRED_FIELD as REQ, HELM_OPTIONAL_FIELDS as OPT, HELM_RGROUP_FIELDS as RGP,
+} from '@datagrok-libraries/bio/src/utils/const';
+
+export 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;
+}
+
+/* eslint-disable camelcase */
+export abstract class DummyWebEditorMonomer implements IWebEditorMonomer {
+  //@formatter:off
+  public abstract get backgroundcolor(): string | undefined;
+  public abstract get linecolor(): string | undefined;
+  public abstract get textcolor(): string | undefined;
+  //@formatter:on
+
+  get issmiles(): boolean { return !!this.smiles; }
+
+  /** R-Group index os single digit only is allowed in Pistoia code */
+  public readonly at: WebEditorRGroups = {
+    R1: 'H', R2: 'H', R3: 'H', R4: 'H', R5: 'H', R6: 'H', R7: 'H', R8: 'H', R9: 'H'
+  };
+
+  public get rs(): number { return Object.keys(this.at).length; }
+
+  protected constructor(
+    public readonly biotype: string,
+    /** symbol */ public readonly id: string,
+    /** name */ public readonly n: string | undefined = 'missing',
+    /** molfile */ public readonly m: string | undefined = undefined,
+    /* Pistoia.HELM deletes .type and .mt in Monomers.addOneMonomer() */
+    /** polymer type */ public readonly type: PolymerType | undefined = undefined,
+    /** monomer type */ public readonly mt: MonomerType | undefined = undefined,
+    public readonly smiles?: string,
+  ) {
+    if (!this.id)
+      throw new Error('Invalid arg undefined [id].');
+
+    // return new Proxy(this, {
+    //   get: (target: any, prop: string | symbol, _receiver: any) => {
+    //     const logPrefix = `${this.toLog()}.proxy.get( '${String(prop)}' )`;
+    //     switch (prop) {
+    //     case 'id':
+    //     case 'at':
+    //     case 'na':
+    //     case 'nature':
+    //     case 'backgroundcolor':
+    //     case 'linecolor':
+    //     case 'textcolor': {
+    //       // these attributes are known and handled
+    //       return target[prop];
+    //     }
+    //     case 'rs': {
+    //       /* R-Group count (?), 2 is default for monomer "?" */
+    //       throw new Error('Not supported get "rs" attribute.');
+    //     }
+    //     default:
+    //       // Unexpected attribute requested
+    //       _package.logger.warning(`${logPrefix}`);
+    //       return target[prop];
+    //     }
+    //   },
+    //   set: (target, prop, value: any, _receiver: any): boolean => {
+    //     throw new Error(`Not supported set '${String(prop)}' attribute, any.`);
+    //   },
+    //   apply: (target: any, thisArg: any, argArray: any[]): any | undefined => {
+    //     throw new Error(`Not supported call (apply) '${thisArg.toString()}' method, any.`);
+    //   }
+    // });
+  }
+
+  private static objCounter: number = -1;
+  private readonly objId: number = ++DummyWebEditorMonomer.objCounter;
+
+  private readonly className: string = 'DummyWebEditorMonomer';
+
+  protected toLog(): string {
+    return `Helm: ${this.className}<${this.objId}>`;
+  }
+}
+
+export class GapWebEditorMonomer extends DummyWebEditorMonomer {
+  public readonly backgroundcolor: string = '#FFFFFF';
+  public readonly linecolor: string = '#808080';
+  public readonly textcolor: string = '#808080';
+
+  constructor(biotype: string, id: string) {
+    super(biotype, id, 'gap');
+  }
+}
+
+export class AmbiguousWebEditorMonomer extends DummyWebEditorMonomer {
+  public readonly backgroundcolor: string = '#808080';
+  public readonly linecolor: string = '#000000';
+  public readonly textcolor: string = '#000000';
+
+  constructor(biotype: string, id: string) {
+    super(biotype, id, 'ambiguous');
+  }
+}
+
+export class MissingWebEditorMonomer extends DummyWebEditorMonomer {
+  public readonly backgroundcolor: string = '#FF4444';
+  public readonly linecolor: string = '#800000';
+  public readonly textcolor: string = '#FFFFFF';
+
+  constructor(biotype: string, id: string) {
+    super(biotype, id, 'missing');
+  }
+}
+
+export class BrokenWebEditorMonomer extends DummyWebEditorMonomer {
+  public readonly backgroundcolor: string = '#FFFF44';
+  public readonly linecolor: string = '#800000';
+  public readonly textcolor: string = '#000000';
+
+  constructor(biotype: string, id: string) {
+    super(biotype, id, 'broken');
+  }
+}

package/src/utils/get-monomer-of-library.ts

@@ -0,0 +1,90 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {
+  HelmType, IWebEditorMonomer, IMonomerColors, MonomerType, PolymerType, WebEditorRGroups
+} from '@datagrok-libraries/bio/src/helm/types';
+import {Monomer} from '@datagrok-libraries/bio/src/types';
+import {
+  HELM_OPTIONAL_FIELDS as OPT, HELM_REQUIRED_FIELD as REQ, HELM_RGROUP_FIELDS as RGP
+} from '@datagrok-libraries/bio/src/utils/const';
+import {BrokenWebEditorMonomer, getRS, MissingWebEditorMonomer} from './get-monomer-dummy';
+
+function getMonomerColors(monomer: Monomer): IMonomerColors | null {
+  const currentMonomerSchema = 'default';
+  let monomerSchema: string = currentMonomerSchema;
+  if (!monomer.meta || !monomer.meta.colors) return null;
+
+  const monomerColors: { [colorSchemaName: string]: any } = monomer.meta.colors;
+
+  if (!(currentMonomerSchema in monomerColors)) monomerSchema = 'default';
+
+  const res = monomerColors[monomerSchema];
+
+  return !res ? null : {
+    textcolor: res.text ?? res.textColor,
+    linecolor: res.line ?? res.lineColor,
+    backgroundcolor: res.background ?? res.backgroundColor
+  } as IMonomerColors;
+}
+
+export class LibraryWebEditorMonomer implements IWebEditorMonomer {
+  public get rs(): number { return Object.keys(this.at).length; }
+
+  public get issmiles(): boolean { return !!this.smiles; }
+
+  public linecolor?: string;
+  public backgroundcolor?: string;
+  public textcolor?: string;
+
+  /* eslint-disable max-params */
+  protected constructor(
+    public readonly id: string,
+    public readonly m: string,
+    public readonly n: string,
+    public readonly na: string | undefined,
+    public readonly type: PolymerType,
+    public readonly mt: MonomerType,
+    public readonly at: WebEditorRGroups,
+    public readonly smiles?: string,
+  ) /* eslint-enable max-params */ {}
+
+  static fromMonomer(biotype: HelmType, monomer: Monomer): IWebEditorMonomer {
+    let at: WebEditorRGroups = {};
+    const symbol = monomer[REQ.SYMBOL];
+    const smiles = monomer[REQ.SMILES];
+    if (monomer.rgroups.length > 0) {
+      monomer.rgroups.forEach((it) => {
+        at[it[RGP.LABEL]] = it[RGP.CAP_GROUP_NAME];
+      });
+    } else if (smiles) {
+      // Generate R-Groups from SMILES
+      at = getRS(smiles);
+    } else if (!monomer.lib) {
+      // missing
+      return new MissingWebEditorMonomer(biotype, symbol);
+    } else {
+      // broken
+      return new BrokenWebEditorMonomer(biotype, symbol);
+    }
+
+    const res = new LibraryWebEditorMonomer(
+      monomer[REQ.SYMBOL],
+      monomer[REQ.MOLFILE],
+      monomer[REQ.NAME],
+      monomer[OPT.NATURAL_ANALOG],
+      monomer[REQ.POLYMER_TYPE],
+      monomer[REQ.MONOMER_TYPE],
+      at);
+
+    const colors = getMonomerColors(monomer);
+    if (colors) {
+      res.textcolor = colors?.textcolor;
+      res.linecolor = colors?.linecolor;
+      res.backgroundcolor = colors?.backgroundcolor;
+    }
+
+    return res;
+  }
+}

package/src/utils/get-monomer.ts

@@ -0,0 +1,113 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {ILogger} from '@datagrok-libraries/bio/src/utils/logger';
+import {IMonomerLib, Monomer} from '@datagrok-libraries/bio/src/types';
+import {Atom, HelmType, IWebEditorMonomer, GetMonomerResType} from '@datagrok-libraries/bio/src/helm/types';
+import {helmTypeToPolymerType} from '@datagrok-libraries/bio/src/monomer-works/monomer-works';
+import {
+  HELM_REQUIRED_FIELD as REQ
+} from '@datagrok-libraries/bio/src/utils/const';
+import {HelmTypes} from '@datagrok-libraries/bio/src/helm/consts';
+
+import {AmbiguousWebEditorMonomer, GapWebEditorMonomer, MissingWebEditorMonomer} from './get-monomer-dummy';
+import {LibraryWebEditorMonomer} from './get-monomer-of-library';
+import {OrgHelmModule, ScilModule} from '../types';
+
+import {_package} from '../package';
+
+declare const org: OrgHelmModule;
+declare const scil: ScilModule;
+
+const monomerRe = /[\w()]+/;
+//** Do not mess with monomer symbol with parenthesis enclosed in square brackets */
+const ambMonomerRe = RegExp(String.raw`\(${monomerRe}(,${monomerRe})+\)`);
+
+type GetMonomerOverridingFunc = (
+  a: Atom<HelmType> | HelmType, name: string | undefined, monomerLib: IMonomerLib,
+  originalGetMonomer: (a: Atom<HelmType> | HelmType, name: string) => GetMonomerResType) => GetMonomerResType;
+
+export function getMonomerOverrideAndLogAlert(
+  monomerLib: IMonomerLib, getMonomerOverriding: GetMonomerOverridingFunc, trigger: () => void, logger: ILogger,
+): void {
+  const logPrefix = 'Helm: overrideGetMonomerAndAlert()';
+  const monomers = org.helm.webeditor.Monomers;
+  const getMonomerOriginal = monomers.getMonomer.bind(monomers);
+  const alertOriginal = scil.Utils.alert;
+  try {
+    org.helm.webeditor.Monomers.getMonomer =
+      (a: Atom<HelmType> | HelmType, name?: string): GetMonomerResType => {
+        return getMonomerOverriding(a, name, monomerLib, getMonomerOriginal);
+      };
+    // Preventing alert message box for missing monomers with compressed Scilligence.JSDraw2.Lite.js
+    scil.Utils.alert = (s: string): void => {
+      logger.warning(`${logPrefix}, scil.Utils.alert() s = 's'.`);
+    };
+    trigger();
+  } finally {
+    monomers.getMonomer = getMonomerOriginal;
+    scil.Utils.alert = alertOriginal;
+  }
+}
+
+/** Inputs logic */
+export function getMonomerHandleArgs(
+  a: Atom<HelmType> | HelmType, name?: string
+): [/** biotype */ HelmType, /** elem */ string] {
+  let biotype: HelmType;
+  let elem: string;
+  if ((a as Atom<HelmType>).T === 'ATOM') {
+    biotype = (a as Atom<HelmType>).biotype()!;
+    elem = (a as Atom<HelmType>).elem;
+  } else {
+    biotype = a as HelmType;
+    elem = org.helm.webeditor.IO.trimBracket(name!);
+  }
+  return [biotype, elem];
+}
+
+
+/** Substitutes {@link org.helm.webeditor.Monomers.getMonomer()} */
+export function getWebEditorMonomer(
+  monomerLib: IMonomerLib,
+  a: Atom<HelmType> | HelmType, argName?: string,
+): IWebEditorMonomer | null {
+  const [biotype, elem] = getMonomerHandleArgs(a, argName);
+  const pt = helmTypeToPolymerType(biotype);
+
+  /** Get or create {@link Monomer} object (in case it is missing in monomer library current config) */
+  let m: Monomer | null = monomerLib.getMonomer(pt, elem);
+  if (m && biotype == HelmTypes.LINKER && m[REQ.RGROUPS].length != 2) {
+    // Web Editor expects null
+    return null;
+  }
+  if (m && biotype == HelmTypes.SUGAR && m[REQ.RGROUPS].length != 3) {
+    // Web Editor expects null
+    return null;
+  }
+  if (!m /* && biotype != HelmTypes.LINKER*/)
+    m = monomerLib.addMissingMonomer(pt, elem);
+
+  /** Get or create {@link org,helm.WebEditorMonomer} */
+  let resWem: IWebEditorMonomer | null = m.wem ?? null;
+  if (!resWem) {
+    if (elem === '*')
+      resWem = m.wem = new GapWebEditorMonomer(biotype, elem);
+    else if (
+      (biotype === 'HELM_NUCLETIDE' && elem === 'N') ||
+      (biotype === 'HELM_AA' && elem === 'X') ||
+      (biotype === 'HELM_CHEM' && false) || // TODO: Ambiguous monomer for CHEM
+      ambMonomerRe.test(elem) // e.g. (A,R,_)
+    )
+      resWem = m.wem = new AmbiguousWebEditorMonomer(biotype, elem);
+    else if (!m.lib)
+      resWem = m.wem = new MissingWebEditorMonomer(biotype, elem);
+
+
+    if (!resWem)
+      resWem = m.wem = LibraryWebEditorMonomer.fromMonomer(biotype, m);
+  }
+
+  return resWem;
+}

package/src/utils/helm-grid-cell-renderer.ts

@@ -2,9 +2,9 @@ import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 import * as ui from 'datagrok-api/ui';
 
-import * as JSDraw2 from 'JSDraw2';
 import wu from 'wu';
 
+import {HelmType, Mol} from '@datagrok-libraries/bio/src/helm/types';
 import {
   CellRendererBackAsyncBase, RenderServiceBase
 } from '@datagrok-libraries/bio/src/utils/cell-renderer-async-base';
@@ -16,7 +16,6 @@ import {_getHelmService} from '../package-utils';
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
 import {ILogger} from '@datagrok-libraries/bio/src/utils/logger';
 import {getGridCellRendererBack} from '@datagrok-libraries/bio/src/utils/cell-renderer-back-base';
-import {IMonomerLib} from '@datagrok-libraries/bio/src/types/index';
 
 import {_package, getMonomerLib} from '../package';
 
@@ -44,15 +43,19 @@ class WrapLogger implements ILogger {
 
 export class HelmGridCellRendererBack extends CellRendererBackAsyncBase<HelmProps, HelmAux> {
   private _auxList: (HelmAux | null)[];
-  private readonly monomerLib: IMonomerLib;
 
   constructor(
     gridCol: DG.GridColumn | null,
     tableCol: DG.Column<string>,
   ) {
     super(gridCol, tableCol, new WrapLogger(_package.logger) /* _package.logger */, true);
-    this.monomerLib = getMonomerLib();
-    this.subs.push(this.monomerLib.onChanged.subscribe(this.monomerLibOnChanged.bind(this)));
+
+    const monomerLib = getMonomerLib();
+    if (!monomerLib)
+      throw new Error('Helm package is not initialized yet.');
+    this.subs.push(monomerLib.onChanged.subscribe(() => {
+      this.reset();
+    }));
   }
 
   protected override reset(): void {
@@ -138,7 +141,7 @@ export class HelmGridCellRendererBack extends CellRendererBackAsyncBase<HelmProp
     const argsX = (e.offsetX - gcb.x) * dpr;
     const argsY = (e.offsetY - gcb.y) * dpr;
 
-    const editorMol: JSDraw2.IEditorMol | null = aux.mol;
+    const editorMol: Mol<HelmType> | null = aux.mol;
     if (!editorMol) {
       this.logger.warning(`${logPrefix}, editorMol of the cell not found.`);
       return; // The gridCell is not rendered yet
@@ -146,7 +149,9 @@ export class HelmGridCellRendererBack extends CellRendererBackAsyncBase<HelmProp
     const seqMonomer: ISeqMonomer | null = getHoveredMonomerFromEditorMol(argsX, argsY, gridCell, editorMol);
 
     if (seqMonomer) {
-      const tooltipEl = this.monomerLib.getTooltip(seqMonomer.polymerType, seqMonomer.symbol);
+      const monomerLib = getMonomerLib();
+      const tooltipEl = monomerLib ? monomerLib.getTooltip(seqMonomer.polymerType, seqMonomer.symbol) :
+        ui.divText('Monomer library is not available');
       ui.tooltip.show(tooltipEl, e.x + 16, e.y + 16);
     } else {
       // Tooltip for missing monomers