@datagrok/bio 2.15.3 → 2.15.5

package/src/utils/helm-to-molfile/converter/monomer-wrapper.ts

@@ -1,4 +1,4 @@
-import {IMonomerLib, Monomer} from '@datagrok-libraries/bio/src/types';
+import {IMonomerLib, IMonomerLibBase, Monomer} from '@datagrok-libraries/bio/src/types';
 import {HELM_RGROUP_FIELDS} from '@datagrok-libraries/bio/src/utils/const';
 import {RDModule, RDMol} from '@datagrok-libraries/chem-meta/src/rdkit-api';
 import {MolfileHandler} from '@datagrok-libraries/chem-meta/src/parsing-utils/molfile-handler';
@@ -17,7 +17,7 @@ export class MonomerWrapper {
     private helm: Helm,
     shift: { x: number, y: number },
     rdKitModule: RDModule,
-    private readonly monomerLib: IMonomerLib
+    private readonly monomerLib: IMonomerLibBase
   ) {
     const libraryMonomerObject = this.getLibraryMonomerObject();
 

package/src/utils/helm-to-molfile/converter/polymer.ts

@@ -1,18 +1,21 @@
+import wu from 'wu';
+
 import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
 import {V3K_CONST} from '@datagrok-libraries/chem-meta/src/formats/molfile-const';
-import {IMonomerLib} from '@datagrok-libraries/bio/src/types/index';
-
-import wu from 'wu';
+import {HelmTypes, PolymerTypes} from '@datagrok-libraries/bio/src/helm/consts';
+import {IMonomerLib, IMonomerLibBase} from '@datagrok-libraries/bio/src/types/index';
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {GapOriginals} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
+import {MolfileWithMap, MonomerMap} from '@datagrok-libraries/bio/src/monomer-works/types';
 
 import {Helm} from './helm';
 import {MonomerWrapper} from './monomer-wrapper';
-import {MolfileWithMap, MonomerMap} from './types';
 
 export class Polymer {
   constructor(
     helmString: string,
     private readonly rdKitModule: RDModule,
-    private readonly monomerLib: IMonomerLib
+    private readonly monomerLib: IMonomerLibBase
   ) {
     this.helm = new Helm(helmString);
   }
@@ -22,11 +25,14 @@ export class Polymer {
 
   addMonomer(
     monomerSymbol: string,
-    monomerIdx: number,
+    helmMonomerIdx: number,
     shift: { x: number, y: number },
   ): void {
+    if (monomerSymbol === GapOriginals[NOTATION.HELM]) return;
+
+    const molMonomerIdx: number = this.monomerWrappers.length;
     const monomerWrapper = new MonomerWrapper(
-      monomerSymbol, monomerIdx, this.helm, shift, this.rdKitModule, this.monomerLib);
+      monomerSymbol, molMonomerIdx, this.helm, shift, this.rdKitModule, this.monomerLib);
 
     this.monomerWrappers.push(monomerWrapper);
   }
@@ -64,21 +70,22 @@ export class Polymer {
 
     this.restoreBondsBetweenMonomers();
 
-    const monomers: MonomerMap[] = new Array<MonomerMap>(this.monomerWrappers.length);
+    const monomers: MonomerMap = new MonomerMap();
     for (const [mw, mwI] of wu.enumerate(this.monomerWrappers)) {
-      const mwAtomFirst = atomLines.length;
-      const mwBondFirst = bondLines.length;
+      const mAtomFirst = atomLines.length;
+      const mBondFirst = bondLines.length;
 
       atomLines.push(...mw.getAtomLines());
       bondLines.push(...mw.getBondLines());
 
-      monomers[mwI] = {
-        position: mwI,
-        // TODO: PolymerType
+      const polymerType = this.helm.getPolymerTypeByMonomerIdx(mwI);
+      const biotype = polymerType == PolymerTypes.RNA ? HelmTypes.NUCLEOTIDE : HelmTypes.AA;
+      monomers.set(mwI, {
+        biotype: biotype,
         symbol: mw.monomerSymbol,
-        atoms: wu.count(mwAtomFirst).take(mw.atomCount).toArray(),
-        bonds: wu.count(mwBondFirst).take(mw.bondCount).toArray(),
-      };
+        atoms: wu.count(mAtomFirst).take(mw.atomCount).toArray(),
+        bonds: wu.count(mBondFirst).take(mw.bondCount).toArray(),
+      });
     }
 
     const atomCount = atomLines.length;

package/src/utils/helm-to-molfile/converter/types.ts

@@ -11,13 +11,3 @@ export type PositionInBonds = {
   nodeIdx: number,
 }
 
-export type MonomerMap = { position: number, symbol: string, atoms: number[], bonds: number[] };
-
-export class MolfileWithMap {
-  constructor(
-    public readonly molfile: string,
-    public readonly monomers: MonomerMap[]
-  ) {}
-
-  static empty() { return new MolfileWithMap('', []); }
-}

package/src/utils/helm-to-molfile/utils.ts

@@ -2,27 +2,30 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {_package} from '../../package';
+import {IMonomerLibBase} from '@datagrok-libraries/bio/src/types';
+
 import {SeqHelper} from '../seq-helper';
 
+import {_package, getMonomerLib} from '../../package';
 
 /** Translate HELM column into molfile column and append to the dataframe */
 export async function getMolColumnFromHelm(
-  df: DG.DataFrame, helmCol: DG.Column<string>, chiralityEngine: boolean = true
+  df: DG.DataFrame, helmCol: DG.Column<string>, chiralityEngine: boolean = true, monomerLib: IMonomerLibBase
 ): Promise<DG.Column<string>> {
   const seqHelper = await SeqHelper.getInstance();
-  const converter = seqHelper.getHelmToMolfileConverter(df, helmCol);
-  const molCol = converter.convertToRdKitBeautifiedMolfileColumn(chiralityEngine, _package.rdKitModule);
+  const converter = seqHelper.getHelmToMolfileConverter(monomerLib);
+  const molCol = converter.convertToRdKitBeautifiedMolfileColumn(helmCol, chiralityEngine, _package.rdKitModule, monomerLib);
   molCol.semType = DG.SEMTYPE.MOLECULE;
   return molCol;
 }
 
 export async function getSmilesColumnFromHelm(
-  df: DG.DataFrame, helmCol: DG.Column<string>
+  helmCol: DG.Column<string>
 ): Promise<DG.Column<string>> {
   const seqHelper = await SeqHelper.getInstance();
-  const converter = seqHelper.getHelmToMolfileConverter(df, helmCol);
-  const smilesCol = converter.convertToSmiles(_package.rdKitModule);
+  const monomerLib = getMonomerLib();
+  const converter = seqHelper.getHelmToMolfileConverter(monomerLib);
+  const smilesCol = converter.convertToSmiles(helmCol);
   smilesCol.semType = DG.SEMTYPE.MOLECULE;
   return smilesCol;
 }

package/src/utils/monomer-lib/lib-manager.ts

@@ -34,7 +34,7 @@ export class MonomerLibManager implements IMonomerLibHelper {
 
   public get eventManager(): IMonomerLibFileEventManager { return this._eventManager; }
 
-  public async awaitLoaded(timeout: number = 3000): Promise<void> {
+  public async awaitLoaded(timeout: number = 5000): Promise<void> {
     return await Promise.race([
       (async () => {
         const fileManager = await this.getFileManager();
@@ -47,7 +47,7 @@ export class MonomerLibManager implements IMonomerLibHelper {
       })(),
     ]).then((res) => {
       if (!res)
-        throw new Error(`Loading monomer libraries is timeout ${timeout} ms.`);
+        throw new Error(`Loading monomer libraries timeout ${timeout} ms.`);
     });
   }
 

package/src/utils/monomer-lib/monomer-colors.ts

@@ -0,0 +1,68 @@
+import {HelmTypes} from '@datagrok-libraries/bio/src/helm/consts';
+import {Helm} from '../helm-to-molfile/converter/helm';
+import {HelmType} from '@datagrok-libraries/bio/src/helm/types';
+
+/**
+ * MonomerColors class from HelmWebEditor for natural monomers
+ */
+export const naturalMonomerColors = {
+  [HelmTypes.BASE]: {
+    A: "#A0A0FF",
+    G: "#FF7070",
+    T: "#A0FFA0",
+    C: "#FF8C4B",
+    U: "#FF8080"
+  },
+
+  [HelmTypes.NUCLEOTIDE]: {
+    A: "#A0A0FF",
+    G: "#FF7070",
+    T: "#A0FFA0",
+    C: "#FF8C4B",
+    U: "#FF8080"
+  },
+
+  [HelmTypes.LINKER]: {
+    P: "#9aa5e1",
+    p: "#9aa5e1"
+  },
+
+  [HelmTypes.SUGAR]: {
+    R: "#7a85c1",
+    r: "#7a85c1",
+    // TODO: deoxyribose
+  },
+
+  [HelmTypes.AA]: {
+    A: "#C8C8C8",
+    R: "#145AFF",
+    N: "#00DCDC",
+    D: "#E60A0A",
+    C: "#E6E600",
+    E: "#00DCDC",
+    Q: "#E60A0A",
+    G: "#EBEBEB",
+    H: "#8282D2",
+    I: "#0F820F",
+    L: "#0F820F",
+    K: "#145AFF",
+    M: "#E6E600",
+    F: "#3232AA",
+    P: "#DC9682",
+    S: "#FA9600",
+    T: "#FA9600",
+    W: "#B45AB4",
+    Y: "#3232AA",
+    V: "#0F820F"
+  },
+
+  [HelmTypes.CHEM]: {
+    R: "#eeeeee",
+  },
+
+  [HelmTypes.BLOB]: {
+    B: "#999999",
+    G: "#e2e2e2"
+  }
+};
+

package/src/utils/monomer-lib/monomer-lib-base.ts

@@ -0,0 +1,165 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import wu from 'wu';
+
+import {IMonomerLibBase, Monomer, RGroup} from '@datagrok-libraries/bio/src/types/index';
+import {HelmAtom, HelmType, IWebEditorMonomer, MonomerType, PolymerType} from '@datagrok-libraries/bio/src/helm/types';
+import {getMonomerHandleArgs} from '@datagrok-libraries/bio/src/helm/helm-helper';
+import {helmTypeToPolymerType} from '@datagrok-libraries/bio/src/monomer-works/monomer-works';
+import {HelmTypes, PolymerTypes} from '@datagrok-libraries/bio/src/helm/consts';
+import {HELM_REQUIRED_FIELD as REQ, HELM_RGROUP_FIELDS as RGP} from '@datagrok-libraries/bio/src/utils/const';
+import {GapOriginals, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
+
+import {AmbiguousWebEditorMonomer, GapWebEditorMonomer, MissingWebEditorMonomer} from './web-editor-monomer-dummy';
+import {LibraryWebEditorMonomer} from './web-editor-monomer-of-library';
+
+import {_package} from '../../package';
+import {Observable, Subject} from 'rxjs';
+
+const monomerRe = /[\w()]+/;
+//** Do not mess with monomer symbol with parenthesis enclosed in square brackets */
+const ambMonomerRe = RegExp(String.raw`\(${monomerRe}(,${monomerRe})+\)`);
+
+export type MonomerLibDataType = { [polymerType: string]: { [monomerSymbol: string]: Monomer } };
+
+export class MonomerLibBase implements IMonomerLibBase {
+  protected _onChanged = new Subject<any>();
+
+  get onChanged(): Observable<any> { return this._onChanged; }
+
+  constructor(
+    protected _monomers: MonomerLibDataType,
+  ) {}
+
+  /** Creates missing {@link Monomer} */
+  addMissingMonomer(polymerType: PolymerType, monomerSymbol: string): Monomer {
+    let mSet = this._monomers[polymerType];
+    if (!mSet)
+      mSet = this._monomers[polymerType] = {};
+
+    let monomerName: string = monomerSymbol;
+    if (monomerSymbol === GapOriginals[NOTATION.HELM])
+      monomerName = 'Gap';
+    else if (polymerType === PolymerTypes.PEPTIDE && monomerSymbol === 'X')
+      monomerName = 'Any';
+    else if (polymerType === PolymerTypes.RNA && monomerSymbol === 'N')
+      monomerName = 'Any';
+
+    const m = mSet[monomerSymbol] = {
+      [REQ.SYMBOL]: monomerSymbol,
+      [REQ.NAME]: monomerName,
+      [REQ.MOLFILE]: '',
+      [REQ.AUTHOR]: 'MISSING',
+      [REQ.ID]: -1,
+      [REQ.RGROUPS]:
+        wu.count(1).take(9).map((i) => {
+          return {
+            /* eslint-disable no-multi-spaces */
+            // Samples                        //  PEPTIDE     RNA
+            [RGP.CAP_GROUP_SMILES]: '',       // '[*:1][H]'  '[*:1][H]'
+            [RGP.ALTERNATE_ID]: '',           // 'R1-H'      'R1-H'
+            [RGP.CAP_GROUP_NAME]: '',         // 'H'         'H'
+            [RGP.LABEL]: `R${i.toString()}`,  // 'R1'        'R1'
+            /* eslint-enable no-multi-spaces */
+          } as RGroup;
+        }).toArray(),
+      [REQ.SMILES]: '',
+      [REQ.POLYMER_TYPE]: polymerType,
+      [REQ.MONOMER_TYPE]: undefined as unknown as MonomerType, // TODO: Can we get monomerType from atom of POM
+      [REQ.CREATE_DATE]: null,
+    } as Monomer;
+    return m;
+  }
+
+  getMonomer(polymerType: PolymerType | null, argMonomerSymbol: string): Monomer | null {
+    const logPrefix = `Bio: MonomerLib.getMonomer()`;
+    // Adjust RNA's 'R' for ribose to 'r' and 'P' for phosphate to 'p' for case-sensitive monomer names.
+    // There are uppercase 'R' and 'P' at RNA samples in test data 'helm2.csv' but lowercase in HELMCoreLibrary.json
+    let monomerSymbol = argMonomerSymbol;
+    if (polymerType == 'RNA' && monomerSymbol == 'R')
+      monomerSymbol = 'r';
+    if (polymerType == 'RNA' && monomerSymbol == 'P')
+      monomerSymbol = 'p';
+
+    let res: Monomer | null = null;
+
+    if (!polymerType) {
+      _package.logger.warning(`${logPrefix} symbol '${argMonomerSymbol}', polymerType not specified.`);
+      // Assume any polymer type
+      for (const [_polymerType, dict] of Object.entries(this._monomers)) {
+        res = dict[monomerSymbol];
+        if (res) break;
+      }
+    } else {
+      const dict = this._monomers[polymerType];
+      res = dict ? dict[monomerSymbol] : null;
+    }
+    return res;
+  }
+
+  /** Substitutes {@link org.helm.webeditor.Monomers.getMonomer()} */
+  getWebEditorMonomer(a: HelmAtom | 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 = this.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 = this.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, this);
+    }
+
+    return resWem!;
+  }
+
+  getRS(smiles: string): { [r: string]: 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;
+  }
+}

package/src/utils/monomer-lib/monomer-lib.ts

@@ -7,40 +7,46 @@ import * as DG from 'datagrok-api/dg';
 import wu from 'wu';
 import {Observable, Subject} from 'rxjs';
 
-import {HelmType, MonomerSetType, MonomerType, PolymerType} from '@datagrok-libraries/bio/src/helm/types';
+import {
+  HelmType, HelmAtom,
+  MonomerSetType, MonomerType, PolymerType, IWebEditorMonomer,
+} from '@datagrok-libraries/bio/src/helm/types';
+import {HelmTypes, PolymerTypes} from '@datagrok-libraries/bio/src/helm/consts';
 import {IMonomerLib, IMonomerSet, Monomer, MonomerLibSummaryType, RGroup} from '@datagrok-libraries/bio/src/types';
-import {HELM_REQUIRED_FIELD as REQ, HELM_RGROUP_FIELDS as RGP} from '@datagrok-libraries/bio/src/utils/const';
+import {HELM_OPTIONAL_FIELDS as OPT, HELM_REQUIRED_FIELD as REQ, HELM_RGROUP_FIELDS as RGP} from '@datagrok-libraries/bio/src/utils/const';
 import {MolfileHandler} from '@datagrok-libraries/chem-meta/src/parsing-utils/molfile-handler';
-import {GapOriginals} from '@datagrok-libraries/bio/src/utils/seq-handler';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {PolymerTypes} from '@datagrok-libraries/bio/src/helm/consts';
 import {helmTypeToPolymerType} from '@datagrok-libraries/bio/src/monomer-works/monomer-works';
+import {getUserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
+import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
+import {GapOriginals} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
+
+import {MonomerLibBase, MonomerLibDataType} from './monomer-lib-base';
 
 import '../../../css/cell-renderer.css';
 
 import {_package} from '../../package';
-import {getUserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
-import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
+
 
 /** Wrapper for monomers obtained from different sources. For managing monomere
  * libraries, use MolfileHandler class instead */
-export class MonomerLib implements IMonomerLib {
-  private _monomers: { [polymerType: string]: { [monomerSymbol: string]: Monomer } } = {};
-  private _onChanged = new Subject<any>();
+export class MonomerLib extends MonomerLibBase implements IMonomerLib {
   private _duplicateMonomers: { [polymerType: string]: { [monomerSymbol: string]: Monomer[] } } = {};
   public get duplicateMonomers(): { [polymerType: string]: { [monomerSymbol: string]: Monomer[] } } {
     return this._duplicateMonomers;
   }
+
   private _duplicatesHandled = true;
   public get duplicatesHandled() { return this._duplicatesHandled; }
+
   private duplicatesNotified: boolean = false;
 
   constructor(
-    monomers: { [polymerType: string]: { [monomerSymbol: string]: Monomer } },
+    monomers: MonomerLibDataType,
     public readonly source: string | undefined = undefined,
     public readonly error: string | undefined = undefined,
   ) {
-    this._monomers = monomers;
+    super(monomers);
     for (const [_monomerType, monomersOfType] of Object.entries(this._monomers)) {
       for (const [_monomerSymbol, monomer] of Object.entries(monomersOfType))
         monomer.lib = this;
@@ -56,46 +62,6 @@ export class MonomerLib implements IMonomerLib {
     return resJSON;
   }
 
-  /** Creates missing {@link Monomer} */
-  addMissingMonomer(polymerType: PolymerType, monomerSymbol: string): Monomer {
-    let mSet = this._monomers[polymerType];
-    if (!mSet)
-      mSet = this._monomers[polymerType] = {};
-
-    let monomerName: string = monomerSymbol;
-    if (monomerSymbol === GapOriginals[NOTATION.HELM])
-      monomerName = 'Gap';
-    else if (polymerType === PolymerTypes.PEPTIDE && monomerSymbol === 'X')
-      monomerName = 'Any';
-    else if (polymerType === PolymerTypes.RNA && monomerSymbol === 'N')
-      monomerName = 'Any';
-
-    const m = mSet[monomerSymbol] = {
-      [REQ.SYMBOL]: monomerSymbol,
-      [REQ.NAME]: monomerName,
-      [REQ.MOLFILE]: '',
-      [REQ.AUTHOR]: 'MISSING',
-      [REQ.ID]: -1,
-      [REQ.RGROUPS]:
-        wu.count(1).take(9).map((i) => {
-          return {
-            /* eslint-disable no-multi-spaces */
-            // Samples                        //  PEPTIDE     RNA
-            [RGP.CAP_GROUP_SMILES]: '',       // '[*:1][H]'  '[*:1][H]'
-            [RGP.ALTERNATE_ID]: '',           // 'R1-H'      'R1-H'
-            [RGP.CAP_GROUP_NAME]: '',         // 'H'         'H'
-            [RGP.LABEL]: `R${i.toString()}`,  // 'R1'        'R1'
-            /* eslint-enable no-multi-spaces */
-          } as RGroup;
-        }).toArray(),
-      [REQ.SMILES]: '',
-      [REQ.POLYMER_TYPE]: polymerType,
-      [REQ.MONOMER_TYPE]: undefined as unknown as MonomerType, // TODO: Can we get monomerType from atom of POM
-      [REQ.CREATE_DATE]: null,
-    } as Monomer;
-    return m;
-  }
-
   getMonomer(polymerType: PolymerType | null, argMonomerSymbol: string): Monomer | null {
     const logPrefix = `Bio: MonomerLib.getMonomer()`;
     // Adjust RNA's 'R' for ribose to 'r' and 'P' for phosphate to 'p' for case-sensitive monomer names.
@@ -181,10 +147,6 @@ export class MonomerLib implements IMonomerLib {
     return monomers.map((monomer) => monomer?.symbol!);
   }
 
-  get onChanged(): Observable<any> {
-    return this._onChanged;
-  }
-
   private _updateLibInt(lib: IMonomerLib): void {
     const typesNew = lib.getPolymerTypes();
     const types = this.getPolymerTypes();
@@ -285,19 +247,8 @@ export class MonomerLib implements IMonomerLib {
     return resStr;
   }
 
-  getTooltip(polymerType: PolymerType, monomerSymbol: string): HTMLElement {
-    // getTooltip(monomer: Monomer): HTMLElement;
-    // getTooltip(monomerOrPolymerType: string | Monomer, symbol?: string): HTMLElement {
-    //   let polymerType: string;
-    //   let monomerSymbol: string;
-    //   if (typeof monomerOrPolymerType === 'string' || monomerOrPolymerType instanceof String) {
-    //     polymerType = monomerOrPolymerType as string;
-    //     monomerSymbol = symbol!;
-    //   } else {
-    //     const m = monomerOrPolymerType as Monomer;
-    //     polymerType = m[HELM_REQUIRED_FIELD.POLYMER_TYPE];
-    //     monomerSymbol = m[HELM_REQUIRED_FIELD.SYMBOL];
-    //   }
+  getTooltip(biotype: HelmType, monomerSymbol: string): HTMLElement {
+    const polymerType = helmTypeToPolymerType(biotype);
     const res = ui.div([], {classes: 'ui-form ui-tooltip'});
     const monomer = this.getMonomer(polymerType, monomerSymbol);
     if (monomer) {

package/src/utils/monomer-lib/web-editor-monomer-dummy.ts

@@ -0,0 +1,121 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {
+  HelmType, PolymerType, MonomerType,
+  IWebEditorMonomer, WebEditorRGroups
+} from '@datagrok-libraries/bio/src/helm/types';
+
+/* eslint-disable camelcase */
+export abstract class WebEditorMonomerDummy 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 = ++WebEditorMonomerDummy.objCounter;
+
+  private readonly className: string = 'WebEditorMonomerDummy';
+
+  protected toLog(): string {
+    return `Helm: ${this.className}<${this.objId}>`;
+  }
+}
+
+export class GapWebEditorMonomer extends WebEditorMonomerDummy {
+  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 WebEditorMonomerDummy {
+  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 WebEditorMonomerDummy {
+  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 WebEditorMonomerDummy {
+  public readonly backgroundcolor: string = '#FFFF44';
+  public readonly linecolor: string = '#800000';
+  public readonly textcolor: string = '#000000';
+
+  constructor(biotype: string, id: string) {
+    super(biotype, id, 'broken');
+  }
+}