@datagrok/helm 2.2.0 → 2.2.1

package/src/utils/get-monomer.ts

@@ -0,0 +1,111 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import * as org from 'org';
+import * as scil from 'scil';
+import * as JSDraw2 from 'JSDraw2';
+import Atom = JSDraw2.Atom;
+
+import {ILogger} from '@datagrok-libraries/bio/src/utils/logger';
+import {HelmType, IMonomerLib, Monomer, WebEditorMonomer} from '@datagrok-libraries/bio/src/types';
+import {helmTypeToPolymerType} from '@datagrok-libraries/bio/src/monomer-works/monomer-works';
+import {PolymerTypes, HelmTypes} from '@datagrok-libraries/bio/src/utils/const';
+import {
+  HELM_REQUIRED_FIELD as REQ
+} from '@datagrok-libraries/bio/src/utils/const';
+
+import {AmbiguousWebEditorMonomer, GapWebEditorMonomer, LibraryWebEditorMonomer} from './dummy-monomer';
+
+const monomerRe = /[\w()]+/;
+//** Do not mess with monomer symbol with parenthesis enclosed in square brackets */
+const ambMonomerRe = RegExp(String.raw`\(${monomerRe}(,${monomerRe})+\)`);
+
+export type GetMonomerResType = WebEditorMonomer | null;
+
+export type GetMonomerFunc = (a: Atom<HelmType> | HelmType, name: string | undefined) => GetMonomerResType;
+type GetMonomerOverridingFunc = (
+  a: Atom<HelmType> | HelmType, name: string, 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,
+): WebEditorMonomer | 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: WebEditorMonomer | undefined = m.wem;
+  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);
+
+    if (!resWem)
+      resWem = m.wem = LibraryWebEditorMonomer.fromMonomer(biotype, m);
+  }
+
+  return resWem;
+}

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

@@ -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,12 @@ 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)));
   }
 
   protected override reset(): void {
@@ -146,7 +142,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

package/src/utils/helm-service.ts

@@ -10,17 +10,17 @@ import $ from 'cash-dom';
 import {Subject, Unsubscribable} from 'rxjs';
 
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
-import {HelmAux, HelmProps, HelmServiceBase} from '@datagrok-libraries/bio/src/viewers/helm-service';
+import {IMonomerLib} from '@datagrok-libraries/bio/src/types/index';
 import {RenderTask} from '@datagrok-libraries/bio/src/utils/cell-renderer-async-base';
+import {HelmAux, HelmProps, HelmServiceBase} from '@datagrok-libraries/bio/src/viewers/helm-service';
 import {svgToImage} from '@datagrok-libraries/utils/src/svg';
 
 import {_package} from '../package';
-import {DummyWebEditorMonomer} from './dummy-monomer';
 
 export class HelmService extends HelmServiceBase {
   private readonly hostDiv: HTMLDivElement;
 
-  private editor: JSDraw2.Editor | null = null;
+  private editor!: JSDraw2.Editor;
   private image: HTMLImageElement | null = null;
 
   constructor() {
@@ -57,46 +57,18 @@ export class HelmService extends HelmServiceBase {
     this.editor.options.height = task.props.height;
     this.editor.resize(task.props.width, task.props.height);
     const helmStr = task.props.helm;
-    let hasMissing: boolean = false;
     if (helmStr) {
-      const monomers = org.helm.webeditor.Monomers;
-      const originalGetMonomer = monomers.getMonomer;
-      const originalAlert = scil.Utils.alert;
-      try {
-        org.helm.webeditor.Monomers.getMonomer = (a: org.helm.IAtom | string, name: string): org.helm.IAtom | null => {
-          let resAtom: any = originalGetMonomer.bind(monomers)(a, name);
-
-          if (!resAtom) {
-            // Input logic
-            if (a == null && name == null)
-              return null;
-
-            let s: string;
-            let biotype: string;
-            if (name == null) {
-              biotype = (a as org.helm.IAtom).biotype();
-              s = (a as org.helm.IAtom).elem;
-            } else {
-              biotype = a as string;
-              s = org.helm.webeditor.IO.trimBracket(name);
-            }
-            resAtom = new DummyWebEditorMonomer(biotype, s);
-            //hasMissing = true;
-          }
-          return resAtom;
-        };
-        // Preventing alert message box for missing monomers with compressed Scilligence.JSDraw2.Lite.js
-        scil.Utils.alert = (s: string): void => {
-          this.logger.warning(`${logPrefix}, scil.Utils.alert() s = 's'.`);
-        };
-        this.logger.debug(`${logPrefix}, editor.setData( '${helmStr}' )`);
-        this.editor.setData(helmStr, 'helm');
-      } finally {
-        monomers.getMonomer = originalGetMonomer;
-        scil.Utils.alert = originalAlert;
-      }
+      // getMonomerOverrideAndLogAlert(
+      //   this.monomerLib,
+      //   getMonomerPatched,
+      //   () => {
+      //     this.logger.debug(`${logPrefix}, editor.setData( '${helmStr}' )`);
+      //     this.editor.setData(helmStr, 'helm');
+      //   }, this.logger);
+      this.logger.debug(`${logPrefix}, editor.setData( '${helmStr}' )`);
+      this.editor.setData(helmStr, 'helm');
     }
-    if (!helmStr || hasMissing)
+    if (!helmStr)
       this.editor.reset();
 
     const bBox = (this.editor.div.children[0] as SVGSVGElement).getBBox();
@@ -155,3 +127,4 @@ export class HelmService extends HelmServiceBase {
 
   async reset(): Promise<void> { }
 }
+