@datagrok/helm 2.4.6 → 2.5.2

package/webpack.config.js

@@ -16,6 +16,11 @@ module.exports = {
       library: {type: 'var', name: `${packageName}_test`},
       import: './src/package-test.ts',
     },
+    dojo: {
+      filename: 'package-dojo.js',
+      library: {type: 'var', name: `${packageName}_dojo`},
+      import: './helm/dojo/package.ts',
+    },
   },
   resolve: {
     fallback: {'url': false},
@@ -29,7 +34,9 @@ module.exports = {
   devServer: {
     contentBase: './dist',
   },
+  // amd: {toUrlUndefined: true},
   module: {
+    noParse: /vendor/,
     rules: [
       {test: /\.js$/, enforce: 'pre', use: ['source-map-loader'], exclude: [/node_modules/]},
       {test: /\.ts(x?)$/, use: 'ts-loader', exclude: [/node_modules/]},

package/src/cell-renderer.ts

@@ -1,162 +0,0 @@
-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 {HelmMol, ISeqMonomer} from '@datagrok-libraries/bio/src/helm/types';
-
-import {errorToConsole} from '@datagrok-libraries/utils/src/to-console';
-import {getGridCellRendererBack} from '@datagrok-libraries/bio/src/utils/cell-renderer-back-base';
-
-import {findMonomers, parseHelm, removeGapsFromHelm} from './utils';
-import {HelmMonomerPlacer} from './helm-monomer-placer';
-import {getHoveredMonomerFallback, getHoveredMonomerFromEditorMol, getSeqMonomerFromHelmAtom} from './utils/get-hovered';
-import {JSDraw2Module} from './types';
-
-import {_package} from './package';
-
-declare const JSDraw2: JSDraw2Module;
-
-const enum tempTAGS {
-  helmSumMaxLengthWords = 'helm-sum-maxLengthWords',
-  helmMaxLengthWords = 'helm-maxLengthWords',
-
-  helmPlacer = 'bio-helmPlacer',
-}
-
-/** Helm cell renderer in case of no missed monomer draws with JSDraw2.Editor (webeditor),
- * in case of missed monomers presented, draws linear sequences aligned in width per monomer.
- */
-export class HelmCellRenderer extends DG.GridCellRenderer {
-  get name() { return 'helm'; }
-
-  get cellType() { return 'helm'; }
-
-  get defaultWidth(): number | null { return 400; }
-
-  get defaultHeight(): number | null { return 100; }
-
-  onMouseMove(gridCell: DG.GridCell, e: MouseEvent): void {
-    try {
-      const [_gridCol, tableCol, temp] =
-        getGridCellRendererBack<string, HelmMonomerPlacer>(gridCell);
-      const helmPlacer = temp['rendererBack'];
-      /* Can not do anything without tableColumn */
-      if (!tableCol) return;
-
-      /** {@link gridCell}.bounds */ const gcb = gridCell.bounds;
-      const argsX = e.offsetX - gcb.x;
-      const argsY = e.offsetY - gcb.y;
-
-      const monomerLib = _package.monomerLib;
-      const editorMol: HelmMol | null = helmPlacer.getEditorMol(gridCell.tableRowIndex!);
-      let seqMonomer: ISeqMonomer | null;
-      let missedMonomers: Set<string> = new Set<string>(); // of .size = 0
-      if (editorMol) {
-        const hoveredAtom = getHoveredMonomerFromEditorMol(argsX, argsY, editorMol, gridCell.bounds.height);
-        seqMonomer = hoveredAtom ? getSeqMonomerFromHelmAtom(hoveredAtom) : null;
-      } else {
-        const seq: string = !gridCell.cell.value ? '' : removeGapsFromHelm(gridCell.cell.value as string);
-        const monomerList = parseHelm(seq);
-        missedMonomers = findMonomers(monomerList, monomerLib);
-        const parsedMonomers = new Set<string>(monomerList);
-        seqMonomer = getHoveredMonomerFallback(argsX, argsY, gridCell, helmPlacer);
-        if (seqMonomer && !parsedMonomers.has(seqMonomer.symbol)) seqMonomer = null;
-        if (seqMonomer) {
-          const textSize = helmPlacer.monomerTextSizeMap[seqMonomer.symbol];
-          if (textSize) {
-            const textBaseLine = gcb.height / 2 -
-              (textSize.fontBoundingBoxAscent + textSize.fontBoundingBoxDescent) / 2 + 1;
-            const textTop = textBaseLine - textSize.fontBoundingBoxAscent;
-            const textBottom = textBaseLine + textSize.fontBoundingBoxDescent;
-            if (argsY < textTop || textBottom < argsY) seqMonomer = null;
-          }
-        }
-      }
-
-      if (seqMonomer) {
-        if (!missedMonomers.has(seqMonomer.symbol)) {
-          const tooltipElements: HTMLElement[] = [ui.div(seqMonomer.symbol)];
-          const monomerDiv = monomerLib ? monomerLib.getTooltip(seqMonomer.polymerType, seqMonomer.symbol) :
-            ui.divText('Monomer library is not available.');
-          tooltipElements.push(monomerDiv);
-          ui.tooltip.show(ui.divV(tooltipElements), e.x + 16, e.y + 16);
-        } else {
-          ui.tooltip.show(ui.divV([
-            ui.divText(`Monomer '${seqMonomer.symbol}' not found.`),
-            ui.divText('Open the Context Panel, then expand Manage Libraries'),
-          ]), e.x + 16, e.y + 16);
-        }
-      } else if (missedMonomers.size == 0) {
-        ui.tooltip.hide();
-        return;
-      } else { // seqMonomer == null && missedMonomers.size > 0
-        const mmStrList = wu(missedMonomers.keys()).toArray().sort()
-          .filter((_, i) => i < 3);
-        const missedMonomersStr = mmStrList.join(', ') + (missedMonomers.size > 3 ? ', ...' : '');
-        ui.tooltip.show(ui.divV([ui.divText('Monomers missed in monomer libraries:'),
-          ui.divText(missedMonomersStr)
-        ]), e.x + 16, e.y + 16);
-      }
-    } catch (err: any) {
-      const errMsg: string = errorToConsole(err);
-      console.error('Helm: HelmCellRenderer.onMouseMove() error:\n' + errMsg);
-    } finally {
-      e.preventDefault();
-      e.stopPropagation();
-    }
-  }
-
-
-  render(g: CanvasRenderingContext2D, x: number, y: number, w: number, h: number,
-    gridCell: DG.GridCell, cellStyle: DG.GridCellStyle
-  ) {
-    g.save();
-    try {
-      const [gridCol, tableCol, temp] =
-        getGridCellRendererBack<string, HelmMonomerPlacer>(gridCell);
-      /* Can not do anything without tableColumn containing temp */
-      if (!tableCol) return;
-      let helmPlacer = temp['rendererBack'];
-      if (!helmPlacer) helmPlacer = temp['rendererBack'] = new HelmMonomerPlacer(gridCol, tableCol);
-
-      const grid = gridCell.gridRow !== -1 ? gridCell.grid : undefined;
-      const missedColor = 'red';
-      const monomerColor: string = '#404040';
-      const frameColor: string = '#C0C0C0';
-
-      const seq: string = !gridCell.cell.value ? '' : removeGapsFromHelm(gridCell.cell.value);
-      const monomerList = parseHelm(seq);
-      const monomers: Set<string> = new Set<string>(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
-        const host = gridCell.element = ui.div([],
-          {style: {width: `${w - 2}px`, height: `${h - 2}px`, margin: `${1}px`, backgroundColor: '#FFE0E0'}});
-        host.setAttribute('dataformat', 'helm');
-        host.setAttribute('data', seq /* gaps skipped */);
-        // if grid has neighbour to the left, then shift host to the left
-        if (host.parentElement && (gridCell.grid?.canvas?.offsetLeft ?? 0) > 0) {
-          host.parentElement.style.left =
-            `${(gridCell.grid?.canvas?.offsetLeft ?? 0) + host.parentElement.offsetLeft}px`;
-        }
-
-        // Recreate editor to avoid hanging in window.dojox.gfx.svg.Text.prototype.getTextWidth
-        const editor = new JSDraw2.Editor(host,
-          {width: w, height: h, skin: 'w8', viewonly: true});
-        helmPlacer.setEditorMol(gridCell.tableRowIndex!, editor.m);
-
-        helmPlacer.skipCell(gridCell.tableRowIndex!);
-        return;
-      }
-
-      if (missedMonomers.size > 0)
-        throw new Error('Unexpected missed monomers');
-    } finally {
-      g.restore();
-    }
-  }
-}

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

@@ -1,149 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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;
-  }
-}