@datagrok/helm 2.1.11 → 2.1.12

package/package.json

@@ -1,20 +1,12 @@
 {
   "name": "@datagrok/helm",
   "friendlyName": "Helm",
-  "version": "2.1.11",
+  "version": "2.1.12",
   "author": {
     "name": "Oleksandra Serhiienko",
     "email": "oserhiienko@datagrok.ai"
   },
   "description": "Provides support for HELM notation (importing, detecting, rendering, conversion).",
-  "dependencies": {
-    "@datagrok-libraries/bio": "^5.32.3",
-    "@datagrok-libraries/utils": "^1.19.1",
-    "cash-dom": "^8.1.1",
-    "datagrok-api": "^1.10.2",
-    "dayjs": "^1.10.6",
-    "rxjs": "^6.5.5"
-  },
   "sources": [
     "css/helm.css",
     "https://ajax.googleapis.com/ajax/libs/dojo/1.10.4/dojo/dojo.js",
@@ -22,8 +14,18 @@
     "helm/JSDraw/Scilligence.JSDraw2.Resources.js",
     "helm/JSDraw/Pistoia.HELM-uncompressed.js"
   ],
+  "dependencies": {
+    "@datagrok-libraries/bio": "^5.32.7",
+    "@datagrok-libraries/utils": "^2.5.0",
+    "cash-dom": "^8.1.1",
+    "datagrok-api": "^1.10.2",
+    "dayjs": "^1.10.6",
+    "rxjs": "^6.5.5"
+  },
   "devDependencies": {
+    "@datagrok/bio": "^2.1.12",
     "path": "^0.12.7",
+    "source-map-loader": "^4.0.1",
     "ts-loader": "^9.2.6",
     "typescript": "^4.4.4",
     "webpack": "^5.59.1",
@@ -35,16 +37,16 @@
   },
   "scripts": {
     "link-all": "npm link datagrok-api  @datagrok-libraries/utils @datagrok-libraries/bio",
-    "debug-helm": "webpack && grok publish ",
+    "debug-helm": "webpack && grok publish",
     "release-helm": "webpack && grok publish --release",
     "build-helm": "webpack",
     "build": "webpack",
-    "debug-local": "grok publish local",
-    "release-local": "grok publish local --release",
-    "debug-helm-dev": "grok publish dev",
-    "release-helm-dev": "grok publish dev --release",
-    "debug-helm-public": "grok publish public",
-    "release-helm-public": "grok publish public --release",
+    "debug-helm-local": "webpack && grok publish local",
+    "release-helm-local": "webpack && grok publish local --release",
+    "debug-helm-dev": "webpack && grok publish dev",
+    "release-helm-dev": "webpack && grok publish dev --release",
+    "debug-helm-public": "webpack && grok publish public",
+    "release-helm-public": "webpack && grok publish public --release",
     "lint": "eslint \"./src/**/*.ts\"",
     "lint-fix": "eslint \"./src/**/*.ts\" --fix",
     "test": "grok test",

package/src/cell-renderer.ts

@@ -2,15 +2,25 @@ 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 {findMonomers, parseHelm, getParts} from './utils';
 import {printLeftOrCentered} from '@datagrok-libraries/bio/src/utils/cell-renderer';
 import {errorToConsole} from '@datagrok-libraries/utils/src/to-console';
 
+const enum tempTAGS {
+  helmSumMaxLengthWords = 'helm-sum-maxLengthWords',
+  helmMaxLengthWords = 'helm-maxLengthWords',
+}
 // Global flag is for replaceAll
 const helmGapStartRe = /\{(\*\.)+/g;
 const helmGapIntRe = /\.(\*\.)+/g;
 const helmGapEndRe = /(\.\*)+\}/g;
 
+type TempType = { [tagName: string]: any };
+
+/** 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'; }
 
@@ -22,8 +32,19 @@ export class HelmCellRenderer extends DG.GridCellRenderer {
 
   onMouseMove(gridCell: DG.GridCell, e: MouseEvent): void {
     try {
-      const maxLengthWordsSum = gridCell.cell.column.temp['helm-sum-maxLengthWords'];
-      const maxIndex = Object.values(gridCell.cell.column.temp['helm-maxLengthWords']).length - 1;
+      /* Can not do anything without tableColumn containing temp */
+      let tableCol: DG.Column | null = null;
+      try { tableCol = gridCell.tableColumn; } catch { }
+      if (!tableCol) return;
+
+      const colTemp: TempType[] = tableCol.temp ?? new Array<TempType>(tableCol.length);
+      // Exit if no missed monomers (tags are not presented in colTemp)
+      if (!colTemp || Object.keys(colTemp).length == 0) return;
+
+      const maxLengthWordsSum: { [pos: number]: number } = colTemp[tempTAGS.helmSumMaxLengthWords];
+      const maxLengthWords: { [pos: number]: number } = colTemp[tempTAGS.helmMaxLengthWords];
+
+      const maxIndex = Object.values(maxLengthWords).length - 1;
       const argsX = e.offsetX - gridCell.gridColumn.left + (gridCell.gridColumn.left - gridCell.bounds.x);
       let left = 0;
       let right = maxIndex;
@@ -51,14 +72,15 @@ export class HelmCellRenderer extends DG.GridCellRenderer {
       const subParts: string[] = parseHelm(s);
       const allParts: string[] = getParts(subParts, s);
       const tooltipMessage: HTMLElement[] = [];
-      for (let i = 0; i < allParts.length; ++i) {
-        if (monomers.has(allParts[i])) {
-          tooltipMessage[i] = ui.divV([
-            ui.divText(`Monomer '${allParts[i]}' not found.`),
+      for (let partI = 0; partI < allParts.length; ++partI) {
+        if (monomers.has(allParts[partI])) {
+          tooltipMessage[partI] = ui.divV([
+            ui.divText(`Monomer ${allParts[partI]} not found.`),
             ui.divText('Open the Context Panel, then expand Manage Libraries')
           ]);
         }
       }
+
       (((tooltipMessage[left]?.childNodes.length ?? 0) > 0)) ?
         ui.tooltip.show(ui.div(tooltipMessage[left]), e.x + 16, e.y + 16) :
         ui.tooltip.hide();
@@ -71,57 +93,71 @@ export class HelmCellRenderer extends DG.GridCellRenderer {
   render(g: CanvasRenderingContext2D, x: number, y: number, w: number, h: number,
     gridCell: DG.GridCell, cellStyle: DG.GridCellStyle
   ) {
-    const grid = gridCell.gridRow !== -1 ? gridCell.grid : undefined;
-    const undefinedColor = 'rgb(100,100,100)';
-    const grayColor = '#808080';
-
-    const s: string = !gridCell.cell.value ? '' : gridCell.cell.value
-      .replaceAll(helmGapStartRe, '{').replaceAll(helmGapIntRe, '.').replaceAll(helmGapEndRe, '}');
-    const monomers = findMonomers(s);
-    const subParts: string[] = parseHelm(s);
-    if (monomers.size == 0 && grid) {
-      const host = ui.div([], {style: {width: `${w}px`, height: `${h}px`}});
-      host.setAttribute('dataformat', 'helm');
-      host.setAttribute('data', s);
-      gridCell.element = host;
-      //@ts-ignore
-      const canvas = new JSDraw2.Editor(host, {width: w, height: h, skin: 'w8', viewonly: true});
-      return;
-    } else {
-      if (!grid) {
-        const r = window.devicePixelRatio;
-        h = 28;
-        g.canvas.height = h * r;
-        g.canvas.style.height = `${h}px`;
-      }
-      w = grid ? Math.min(grid.canvas.width - x, w) : g.canvas.width - x;
-      g.save();
-      g.beginPath();
-      g.rect(x, y, w, h);
-      g.clip();
-      g.font = '12px monospace';
-      g.textBaseline = 'top';
-      let x1 = x;
-      const maxLengthWords: any = {};
-      const maxLengthWordSum: any = {};
-      const allParts: string[] = getParts(subParts, s);
-      for (let i = 0; i < allParts.length; ++i) {
-        maxLengthWords[i] = allParts[i].length * 7;
-        const color = monomers.has(allParts[i]) ? 'red' : grayColor;
-        g.fillStyle = undefinedColor;
-        x1 = printLeftOrCentered(x1, y, w, h, g, allParts[i], color, 0, true, 1.0);
+    g.save();
+    try {
+      /* Can not do anything without tableColumn containing temp */
+      let tableCol: DG.Column | null = null;
+      try { tableCol = gridCell.tableColumn; } catch { }
+      if (!tableCol) return;
+
+      const grid = gridCell.gridRow !== -1 ? gridCell.grid : undefined;
+      const undefinedColor = 'rgb(100,100,100)';
+      const grayColor = '#808080';
+
+      const missedMonomers = findMonomers(gridCell.cell.value);
+      const s: string = gridCell.cell.value ?? '';
+      const subParts: string[] = parseHelm(s);
+
+      if (missedMonomers.size == 0) {
+        const host = ui.div([], {style: {width: `${w}px`, height: `${h}px`}});
+        host.setAttribute('dataformat', 'helm');
+        host.setAttribute('data', gridCell.cell.value);
+        gridCell.element = host;
+        //@ts-ignore
+        const canvas = new JSDraw2.Editor(host, {width: w, height: h, skin: 'w8', viewonly: true});
+        return;
       }
 
-      maxLengthWordSum[0] = maxLengthWords[0];
-      for (let i = 1; i < allParts.length; i++)
-        maxLengthWordSum[i] = maxLengthWordSum[i - 1] + maxLengthWords[i];
+      if (missedMonomers.size > 0) {
+        if (!grid) {
+          const r = window.devicePixelRatio;
+          h = 28;
+          g.canvas.height = h*r;
+          g.canvas.style.height = `${h}px`;
+        }
+        const maxLengthWords: number[] = tableCol.temp[tempTAGS.helmMaxLengthWords] ?? [];
+        if (subParts.length > maxLengthWords.length)
+          maxLengthWords.push(...(new Array<number>(subParts.length - maxLengthWords.length).fill(-1)));
 
-      gridCell.cell.column.temp = {
-        'helm-sum-maxLengthWords': maxLengthWordSum,
-        'helm-maxLengthWords': maxLengthWords
-      };
+        w = grid ? Math.min(grid.canvas.width - x, w) : g.canvas.width - x;
+        g.save();
+        g.beginPath();
+        g.rect(x, y, w, h);
+        g.clip();
+        g.font = '12px monospace';
+        g.textBaseline = 'top';
+        let x1 = x;
+        const allParts: string[] = getParts(subParts, s);
+        for (let i = 0; i < allParts.length; ++i) {
+          maxLengthWords[i] = Math.max(maxLengthWords[i], allParts[i].length * 7); /* What is 7, width of char ? */
+          const color = missedMonomers.has(allParts[i]) ? 'red' : grayColor;
+          g.fillStyle = undefinedColor;
+          x1 = printLeftOrCentered(x1, y, w, h, g, allParts[i], color, 0, true, 1.0);
+        }
+
+        const maxLengthWordSum: number[] = new Array<number>(maxLengthWords.length);
+        maxLengthWordSum[0] = maxLengthWords[0];
+        for (let partI = 1; partI < allParts.length; partI++)
+          maxLengthWordSum[partI] = maxLengthWordSum[partI - 1] + maxLengthWords[partI];
+
+        tableCol.temp = {
+          [tempTAGS.helmSumMaxLengthWords]: maxLengthWordSum,
+          [tempTAGS.helmMaxLengthWords]: maxLengthWords
+        };
+        return;
+      }
+    } finally {
       g.restore();
-      return;
     }
   }
 }

package/src/package-test.ts

@@ -1,7 +1,9 @@
 import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
 import {runTests, tests, TestContext} from '@datagrok-libraries/utils/src/test';
+
 import './tests/helm-tests.ts';
+import './tests/findMonomers-tests';
 
 export const _package = new DG.Package();
 export {tests};

package/src/package.ts

@@ -20,27 +20,35 @@ export async function initHelm(): Promise<void> {
   return Promise.all([new Promise((resolve, reject) => {
     // @ts-ignore
     dojo.ready(function() { resolve(null); });
-  }), await grok.functions.call('Bio:getBioLib')]).then(([_, lib]: [void, IMonomerLib]) => {
-    monomerLib = lib;
-    rewriteLibraries(); // initHelm()
-    monomerLib.onChanged.subscribe((_) => {
-      try {
-        rewriteLibraries(); // initHelm()
-
-        const polymerTypeList: string[] = monomerLib.getPolymerTypes();
-        const msgStr: string = 'Monomer lib updated:<br />' + (
-          polymerTypeList.length == 0 ? 'empty' : polymerTypeList.map((polymerType) => {
-            return `${polymerType} ${monomerLib.getMonomerSymbolsByType(polymerType).length}`;
-          }).join('<br />'));
-
-        grok.shell.info(msgStr);
-      } catch (err: any) {
-        const errMsg = errorToConsole(err);
-        console.error('Helm: initHelm monomerLib.onChanged() error:\n' + errMsg);
-        // throw err; // Prevent disabling event handler
-      }
+  }), grok.functions.call('Bio:getBioLib')])
+    .then(([_, lib]: [void, IMonomerLib]) => {
+      monomerLib = lib;
+      rewriteLibraries(); // initHelm()
+      monomerLib.onChanged.subscribe((_) => {
+        try {
+          rewriteLibraries(); // initHelm()
+
+          const monTypeList: string[] = monomerLib.getPolymerTypes();
+          const msgStr: string = 'Monomer lib updated:<br />' + (
+            monTypeList.length == 0 ? 'empty' : monTypeList.map((monType) => {
+              return `${monType} ${monomerLib.getMonomerSymbolsByType(monType).length}`;
+            }).join('<br />'));
+
+          grok.shell.info(msgStr);
+        } catch (err: any) {
+          const errMsg = errorToConsole(err);
+          console.error('Helm: initHelm monomerLib.onChanged() error:\n' + errMsg);
+          // throw err; // Prevent disabling event handler
+        }
+      });
+    })
+    .catch((err: any) => {
+      const errMsg: string = err instanceof Error ? err.message : !!err ? err.toString() : 'Exception \'undefined\'';
+      grok.shell.error(`Package \'Helm\' init initHelm() error: ${errMsg}`);
+      const errRes = new Error(errMsg);
+      errRes.stack = err.stack;
+      throw errRes;
     });
-  });
 }
 
 function rewriteLibraries() {
@@ -97,12 +105,10 @@ export function helmCellRenderer(): HelmCellRenderer {
 function checkMonomersAndOpenWebEditor(cell?: DG.Cell, value?: string, units?: string) {
   const cellValue = typeof units === 'undefined' ? cell.value : value;
   const monomers = findMonomers(cellValue);
-  if (monomers.size == 0) {
-    webEditor(cell, value, units);
-  } else {
+  if (monomers.size == 0) { webEditor(cell, value, units); } else {
     grok.shell.warning(`Monomers ${Array.from(monomers).join(', ')} are absent! <br/>` +
-    `Please, upload the monomer library! <br/>` +
-    `<a href="https://datagrok.ai/help/domains/bio/macromolecules" target="_blank">Learn more</a>`);
+      `Please, upload the monomer library! <br/>` +
+      `<a href="https://datagrok.ai/help/domains/bio/macromolecules" target="_blank">Learn more</a>`);
   }
 }
 

package/src/tests/findMonomers-tests.ts

@@ -0,0 +1,56 @@
+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-test';
+import {after, before, category, delay, expect, expectObject, test} from '@datagrok-libraries/utils/src/test';
+import {findMonomers} from '../utils';
+import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+
+const LIB_STORAGE_NAME = 'Libraries';
+export const LIB_DEFAULT: { [fileName: string]: string } = {'HELMCoreLibrary.json': 'HELMCoreLibrary.json'};
+
+
+/** Tests with default monomer library */
+category('findMonomers', () => {
+
+  let monomerLibHelper: IMonomerLibHelper;
+  /** Backup actual user's monomer libraries settings */
+  let userLibrariesSettings: any = null;
+
+  before(async () => {
+    monomerLibHelper = await getMonomerLibHelper();
+    userLibrariesSettings = await grok.dapi.userDataStorage.get(LIB_STORAGE_NAME, true);
+
+    // Tests 'findMonomers' requires default monomer library loaded
+    await grok.dapi.userDataStorage.post(LIB_STORAGE_NAME, LIB_DEFAULT, true);
+    await monomerLibHelper.loadLibraries(true); // load default libraries
+  });
+
+  after(async () => {
+    await grok.dapi.userDataStorage.put(LIB_STORAGE_NAME, userLibrariesSettings, true);
+  });
+
+  const tests: { [testName: string]: { test: string, tgt: Set<string> } } = {
+    'withoutMissed': {
+      test: 'PEPTIDE1{meI.hHis.Aca.N.T.dE.Thr_PO3H2.Aca.D-Tyr_Et}$$$$',
+      tgt: new Set<string>(),
+    },
+    'withMissed':
+      {
+        test: 'PEPTIDE1{meI.missed2.Aca.N.T.dE.Thr_PO3H2.Aca.D-Tyr_Et}$$$$',
+        tgt: new Set<string>(['missed2'])
+      }
+  };
+
+  for (const [testName, testData] of Object.entries(tests)) {
+    test(testName, async () => {
+      _testFindMonomers(testData.test, testData.tgt);
+    });
+  }
+
+  function _testFindMonomers(testHelmValue: string, tgtMissedSet: Set<string>): void {
+    const resMissedSet: Set<string> = findMonomers(testHelmValue);
+    expectObject(resMissedSet, tgtMissedSet);
+  }
+});

package/src/tests/helm-tests.ts

@@ -1,9 +1,11 @@
-import {after, before, category, delay, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
-//import {findMonomers, helmToFasta, helmToPeptide, helmToRNA, initHelm} from '../package';
+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-test';
+import {after, before, category, delay, expect, test, expectArray} from '@datagrok-libraries/utils/src/test';
+//import {findMonomers, helmToFasta, helmToPeptide, helmToRNA, initHelm} from '../package';
 import {parseHelm} from '../utils';
-import * as DG from 'datagrok-api/dg';
-import * as grok from 'datagrok-api/grok';
 
 
 category('Helm', () => {

package/src/utils.ts

@@ -1,4 +1,14 @@
 import * as DG from 'datagrok-api/dg';
+import {
+  RGROUP_CAP_GROUP_NAME,
+  RGROUP_CAP_GROUP_SMILES,
+  jsonSdfMonomerLibDict,
+  MONOMER_SYMBOL,
+  RGROUP_ALTER_ID,
+  RGROUPS,
+  RGROUP_LABEL,
+  SDF_MONOMER_NAME
+} from './constants';
 
 export function getParts(subParts: string[], s: string): string[] {
   const j = 0;
@@ -61,7 +71,29 @@ export function parseHelm(s: string) {
   }
   return monomers;
 }
-/* this function returns names of monomers that are NOT in the monomer library */
+
+// /** Find monomers missed in Helm monomer library configured and
+//  * used in org.helm.webeditor / scil.helm.Monomers / org.helm.webeditor.Monomers .
+//  */
+// export function findMonomers(helmString: string) {
+//   //@ts-ignore
+//   const types: string[] = Object.keys(org.helm.webeditor.monomerTypeList());
+//   const monomerNameList: any[] = [];
+//   const monomerNameI: number = 0;
+//   const weMonomers = org.helm.webeditor.Monomers;
+//   for (let typeI = 0; typeI < types.length; typeI++) {
+//     //@ts-ignore
+//     const ofTypeMonomers: {} = weMonomers.getMonomerSet(types[typeI]) ?? {};
+//     Object.keys(ofTypeMonomers).forEach((key) => {
+//       const monomer: any = ofTypeMonomers[key];
+//       monomerNameList[monomerNameI] = monomer.id;
+//       monomerNameI += 1;
+//     });
+//   }
+//   const helmPartList = parseHelm(helmString);
+//   return new Set(helmPartList.filter((val) => !monomerNameList.includes(val)));
+// }
+
 export function findMonomers(helmString: string) {
   //@ts-ignore
   const types = Object.keys(org.helm.webeditor.monomerTypeList());

package/tsconfig.json

@@ -30,7 +30,7 @@
     // "strictNullChecks": true,                    /* Enable strict null checks. */
     // "strictFunctionTypes": true,                 /* Enable strict checking of function types. */
     // "strictBindCallApply": true,                 /* Enable strict 'bind', 'call', and 'apply' methods on functions. */
-    // "strictPropertyInitialization": true,        /* Enable strict checking of property initialization in classes. */
+    "strictPropertyInitialization": false,          /* Enable strict checking of property initialization in classes. */
     // "noImplicitThis": true,                      /* Raise error on 'this' expressions with an implied 'any' type. */
     // "alwaysStrict": true,                        /* Parse in strict mode and emit "use strict" for each source file. */
 

package/webpack.config.js

@@ -12,20 +12,14 @@ module.exports = {
     },
   },
   resolve: {
-    extensions: ['.wasm', '.mjs', '.js', '.json', '.ts', '.tsx'],
+    fallback: {'url': false},
+    extensions: ['.wasm', '.mjs', '.ts', '.js', '.json', '.tsx'],
   },
   module: {
     rules: [
-      {
-        test: /\.ts(x?)$/,
-        use: 'ts-loader',
-        exclude: /node_modules/,
-      },
-      {
-        test: /\.css$/,
-        use: ['style-loader', 'css-loader'],
-        exclude: /node_modules/,
-      },
+      {test: /\.js$/, enforce: 'pre', use: ['source-map-loader']},
+      {test: /\.ts(x?)$/, use: 'ts-loader', exclude: /node_modules/},
+      {test: /\.css$/, use: ['style-loader', 'css-loader'], exclude: /node_modules/},
     ],
   },
   devtool: 'source-map',