@datagrok/helm 2.5.0 → 2.5.2

package/files/tests/peptide.csv

@@ -0,0 +1,14 @@
+id,helm,description
+1,"PEPTIDE1{A.G.C.P.C.T.D.S.C.N}$$$$V2.0","linear natural"
+2,"PEPTIDE1{*.G.C.P.C.T.D.S.C.N}$$$$V2.0","linear natural with start gap"
+2,"PEPTIDE1{A.G.C.P.*.T.D.S.C.N}$$$$V2.0","linear natural with middle gap"
+2,"PEPTIDE1{A.G.C.P.C.T.D.S.C.*}$$$$V2.0","linear natural with end gap"
+3,"PEPTIDE1{[meI].G.C.[Nva].C.[meT].[meD].S.C.[Aca]}$$$$V2.0","linear non-natural"
+3,PEPTIDE1{*.G.C.[Nva].C.[meT].[meD].S.C.[Aca]}$$$$V2.0,linear non-natural with start gap
+3,"PEPTIDE1{[meI].G.C.[Nva].*.[meT].[meD].S.C.[Aca]}$$$$V2.0","linear non-natural with middle gap"
+3,"PEPTIDE1{[meI].G.C.[Nva].C.[meT].[meD].S.C.*}$$$$V2.0","linear non-natural with end gap"
+1,"PEPTIDE1{A.G.C.P.C.T.D.S.C.N}$PEPTIDE1,PEPTIDE1,3:R3-9:R3$$$V2.0","cycled natural"
+2,"PEPTIDE1{*.G.C.P.C.T.D.S.C.N}$PEPTIDE1,PEPTIDE1,3:R3-9:R3$$$V2.0","cycled natural with start gap"
+2,"PEPTIDE1{A.G.C.P.*.T.D.S.C.N}$PEPTIDE1,PEPTIDE1,3:R3-9:R3$$$V2.0","cycled natural with middle gap"
+2,"PEPTIDE1{A.G.C.P.C.T.D.S.C.*}$PEPTIDE1,PEPTIDE1,3:R3-9:R3$$$V2.0","cycled natural with end gap"
+

package/helm/dojo/package.ts

@@ -0,0 +1,41 @@
+import type {DojoWindowType} from './types';
+
+declare const window: Window & DojoWindowType;
+
+export async function initDojo(): Promise<void> {
+  window.dojo$ = window.dojo$ || {};
+  if (!window.dojo$.initPromise) {
+    window.dojo$.initPromise = (async () => {
+      const logPrefix: string = `dojo: _package.initDojo()`;
+      console.debug(`${logPrefix}, start`);
+
+      console.debug(`${logPrefix}, loadModules(), before`);
+      const t1 = window.performance.now();
+      await loadModules();
+      const t2 = window.performance.now();
+      console.debug(`${logPrefix}, loadModules(), after, ET: ${t2 - t1} ms`);
+
+      console.debug(`${logPrefix}, end`);
+    })();
+  }
+  return window.dojo$.initPromise;
+}
+
+const dojoPath = '../../vendor/dojo-1.10.10';
+
+async function loadModules(): Promise<void> {
+  const logPrefix: string = `dojo: _package.loadModules()`;
+
+  const unc = '';
+  window.dojo$.ctx = require.context('../../vendor/dojo-1.10.10', true, /\.js$/);
+  // const unc = '.uncompressed.js'; // '';
+  // window.dojo$.ctx = require.context('../../vendor/dojo-1.10.10', true, /\.js\.uncompressed\.js$/);
+
+  window.dojo$.uncompressed = unc;
+  window.dojo$.ctx(`./dojo/dojo.js${unc}`);
+}
+
+
+(async () => {
+  await initDojo();
+})();

package/helm/dojo/types.ts

@@ -0,0 +1,12 @@
+import type {DojoType, DojoxType} from '@datagrok-libraries/js-draw-lite/src/types/dojo';
+
+export type DojoWindowType = {
+  dojo$: {
+    /** dojo source file postfix: '' for compressed, '.uncompressed.js' for uncompressed */
+    uncompressed: string;
+    ctx: { <T>(id: string): T };
+    initPromise: Promise<void>;
+  },
+  dojo: DojoType;
+  dojox: DojoxType;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@datagrok/helm",
   "friendlyName": "Helm",
-  "version": "2.5.0",
+  "version": "2.5.2",
   "author": {
     "name": "Aleksandr Tanas",
     "email": "atanas@datagrok.ai"
@@ -16,9 +16,9 @@
     "css/helm.css"
   ],
   "dependencies": {
-    "@datagrok-libraries/bio": "^5.42.15",
-    "@datagrok-libraries/chem-meta": "^1.2.5",
-    "@datagrok-libraries/utils": "^4.3.0",
+    "@datagrok-libraries/bio": "^5.44.1",
+    "@datagrok-libraries/chem-meta": "^1.2.7",
+    "@datagrok-libraries/utils": "^4.3.4",
     "cash-dom": "^8.1.1",
     "datagrok-api": "^1.21.1",
     "dayjs": "^1.10.6",
@@ -28,9 +28,10 @@
   "devDependencies": {
     "@datagrok-libraries/helm-web-editor": "^1.1.11",
     "@datagrok-libraries/js-draw-lite": "^0.0.8",
-    "@datagrok/bio": "^2.15.1",
-    "@datagrok/chem": "^1.12.0",
+    "@datagrok/bio": "^2.15.5",
+    "@datagrok/chem": "^1.12.1",
     "@types/node": "17.0.45",
+    "@types/webpack-env": "^1.18.5",
     "@types/wu": "latest",
     "@typescript-eslint/eslint-plugin": "^7.16.0",
     "@typescript-eslint/parser": "^7.16.0",

package/src/helm-helper.ts

@@ -5,29 +5,35 @@ import * as DG from 'datagrok-api/dg';
 import $ from 'cash-dom';
 
 import {
-  App, Atom, HelmType, GetMonomerFunc, GetMonomerResType, HelmString, HelmMol,
-  MonomerExplorer, TabDescType, MonomersFuncs, MonomerSetType, HelmAtom, ISeqMonomer, PolymerType, MonomerType, type DojoType
+  App, Point, HelmAtom, HelmBond, HelmMol, HelmType, GetMonomerFunc, GetMonomerResType,
+  MonomerExplorer, TabDescType, MonomersFuncs, MonomerSetType, ISeqMonomer, PolymerType, MonomerType,
+  DojoType, JSDraw2ModuleType,
 } from '@datagrok-libraries/bio/src/helm/types';
 import {HelmTypes, MonomerTypes, PolymerTypes} from '@datagrok-libraries/bio/src/helm/consts';
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
 import {ILogger} from '@datagrok-libraries/bio/src/utils/logger';
-import {HelmInputBase, IHelmHelper, IHelmInputInitOptions} from '@datagrok-libraries/bio/src/helm/helm-helper';
+import {
+  HelmConvertRes, HelmInputBase, HelmNotSupportedError, IHelmHelper, IHelmInputInitOptions
+} from '@datagrok-libraries/bio/src/helm/helm-helper';
 import {IHelmWebEditor} from '@datagrok-libraries/bio/src/helm/types';
-import {IMonomerLib, IMonomerLinkData, IMonomerSetPlaceholder} from '@datagrok-libraries/bio/src/types/index';
+import {IMonomerLib, IMonomerLibBase, IMonomerLinkData, IMonomerSetPlaceholder} from '@datagrok-libraries/bio/src/types/index';
 import {HelmTabKeys, IHelmDrawOptions} from '@datagrok-libraries/helm-web-editor/src/types/org-helm';
+import {GAP_SYMBOL, GapOriginals, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
 
 import {HelmWebEditor} from './helm-web-editor';
 import {OrgHelmModule, ScilModule} from './types';
-import {getWebEditorMonomer} from './utils/get-monomer';
 import {HelmInput} from './widgets/helm-input';
 import {getHoveredMonomerFromEditorMol} from './utils/get-hovered';
 
 import {_package} from './package';
 
 declare const dojo: DojoType;
+declare const JSDraw2: JSDraw2ModuleType;
 declare const scil: ScilModule;
 declare const org: OrgHelmModule;
 
+const HELM_GAP_SYMBOL: string = GapOriginals[NOTATION.HELM];
+
 export class HelmHelper implements IHelmHelper {
   private static instanceCount: number = 0;
 
@@ -41,7 +47,7 @@ export class HelmHelper implements IHelmHelper {
 
   createHelmInput(name?: string, options?: IHelmInputInitOptions): HelmInputBase {
     try {
-      const monomerLib: IMonomerLib = _package.libHelper!.getMonomerLib();
+      const monomerLib: IMonomerLibBase = _package.libHelper!.getMonomerLib();
       return HelmInput.create(this, monomerLib, name, options);
     } catch (err: any) {
       const [errMsg, errStack] = errInfo(err);
@@ -256,7 +262,7 @@ export class HelmHelper implements IHelmHelper {
           // logger.debug(`${logPrefixInt}, a: ${JSON.stringify(a, helmJsonReplacer)}, name: '${name}'`);
 
           // Creates monomers in lib
-          const dgWem = getWebEditorMonomer(monomerLib, a, name);
+          const dgWem = monomerLib.getWebEditorMonomer(a, name);
 
           return dgWem; //dgWem;
         } catch (err) {
@@ -332,4 +338,69 @@ export class HelmHelper implements IHelmHelper {
       host.remove();
     }
   }
+
+  public parse(helm: string, origin?: Point): HelmMol {
+    const molHandler = new JSDraw2.MolHandler<HelmType>();
+    const plugin = new org.helm.webeditor.Plugin(molHandler);
+    org.helm.webeditor.IO.parseHelm(plugin, helm, origin ?? new JSDraw2.Point(0, 0));
+    return plugin.jsd.m;
+  }
+
+  removeGaps(srcHelm: string): HelmConvertRes {
+    const monomerMap = new Map<number, number>();
+    const mol: HelmMol = this.parse(srcHelm);
+    for (let aI: number = mol.atoms.length - 1; aI >= 0; --aI) {
+      const a = mol.atoms[aI];
+      if (a.elem === HELM_GAP_SYMBOL /* '*' - original */) {
+        const leftBondList: { aI: number, bI: number }[] = [];
+        const rightBondList: { aI: number, bI: number }[] = [];
+        for (let bI: number = mol.bonds.length - 1; bI >= 0; --bI) {
+          const b = mol.bonds[bI];
+          if (b.a1 !== a && b.a2 === a) leftBondList.push({aI, bI});
+          if (b.a1 === a && b.a2 !== a) rightBondList.push({aI, bI});
+        }
+        if (leftBondList.length > 1 || rightBondList.length > 1)
+          throw new HelmNotSupportedError(`Removing a gap monomer #${aI} with more than two bonds is unsupported.`);
+
+        const lb = leftBondList[0];
+        const rb = rightBondList[0];
+        if (lb && !rb) {
+          mol.bonds.splice(lb.bI, 1);
+          mol.atoms.splice(lb.aI, 1);
+        } else if (!lb && rb) {
+          const rb = rightBondList[0];
+          mol.bonds.splice(rb.bI, 1);
+          mol.atoms.splice(rb.aI, 1);
+        } else {
+          if (lb.aI !== rb.aI)
+            throw new Error('Something is really wrong here.');
+
+          // is not enough, breaks the simple polymer
+          //mol.delAtom(a, true);
+
+          const leftBond = mol.bonds[lb.bI];
+          const rightBond = mol.bonds[rb.bI];
+          const a2 = leftBond.a2 = rightBond.a2; // right atom
+          leftBond.r2 = rightBond.r2;
+          leftBond.apo2 = rightBond.apo2;
+
+          if (a2.bonds)
+            throw new Error('Bond list of the atom is not corrected.');
+          // a2.bonds!.splice(a2.bonds!.indexOf(rightBond), 1); // remove the right bond from links of the right atom
+          // a2.bonds!.push(leftBond); // put the left bond to links of the right atom
+
+          mol.bonds.splice(rb.bI, 1); // remove right bond
+          mol.atoms.splice(lb.aI, 1);
+        }
+      }
+    }
+
+    for (let aI: number = 0; aI < mol.atoms.length; ++aI) {
+      const a: HelmAtom = mol.atoms[aI];
+      monomerMap.set(parseInt(a.bio!.continuousId as string) - 1, aI);
+    }
+
+    const resHelm = org.helm.webeditor.IO.getHelm(mol)!;
+    return {srcHelm, resHelm, monomerMap};
+  }
 }

package/src/helm-monomer-placer.ts

@@ -28,6 +28,12 @@ export class HelmMonomerPlacer extends CellRendererBackBase<string> {
     super(gridCol, tableCol, _package.logger);
   }
 
+  render(g: CanvasRenderingContext2D, x: number, y: number, w: number, h: number,
+    gridCell: DG.GridCell, cellStyle: DG.GridCellStyle
+  ) {
+    throw new Error('Not implemented');
+  }
+
   protected override reset(): void {
     this._allPartsList = new Array<string[] | null>(this.tableCol.length).fill(null);
     this._lengthsList = new Array<number[] | null>(this.tableCol.length).fill(null);

package/src/package-test.ts

@@ -5,7 +5,7 @@ import * as grok from 'datagrok-api/grok';
 // import {JSDraw2ModuleType} from '@datagrok/js-draw-lite/src/types/jsdraw2';
 // import {HelmType, OrgHelmModuleType} from '@datagrok/helm-web-editor/src/types/org-helm';
 
-import {runTests, tests, TestContext} from '@datagrok-libraries/utils/src/test';
+import {runTests, tests, TestContext, initAutoTests as initTests } from '@datagrok-libraries/utils/src/test';
 
 import './tests/_first-tests';
 import './tests/helm-tests';
@@ -19,6 +19,7 @@ import './tests/get-monomer-tests';
 import './tests/parse-helm-tests';
 import './tests/helm-web-editor-tests';
 import './tests/helm-input-tests';
+import './tests/helm-helper-tests';
 
 export const _package = new DG.Package();
 export {tests};
@@ -33,3 +34,8 @@ export async function test(category: string, test: string, testContext: TestCont
   const data = await runTests({category, test, testContext, verbose: true});
   return DG.DataFrame.fromObjects(data)!;
 }
+
+//name: initAutoTests
+export async function initAutoTests() {
+  await initTests(_package, _package.getModule('package-test.js'));
+}

package/src/package-utils.ts

@@ -20,6 +20,8 @@ import {HelmService} from './utils/helm-service';
 import {OrgHelmModule, ScilModule} from './types';
 import {rewriteLibraries} from './utils/get-monomer';
 
+import type {DojoWindowType} from '../helm/dojo/types';
+
 import {_package} from './package';
 
 declare const dojo: DojoType;
@@ -29,15 +31,17 @@ declare const org: OrgHelmModule;
 
 type DojoConfigWindowType = {
   dojoConfig: {
+    baseUrl: string,
     packages?: (string | { name: string, location: string })[],
     deps?: string[], callback: Function, has?: any, parseOnLoad?: boolean, async?: boolean | string, locale?: string,
+    loaderPatch: any,
   },
 };
 type HelmWindowType = {
   $helmService?: HelmServiceBase,
-  require: Function,
+  require: any,
 };
-declare const window: Window & DojoConfigWindowType & HweWindow & HelmWindowType;
+declare const window: Window & DojoConfigWindowType & DojoWindowType & HweWindow & HelmWindowType;
 
 export function _getHelmService(): HelmServiceBase {
   let res = window.$helmService;
@@ -46,7 +50,7 @@ export function _getHelmService(): HelmServiceBase {
 }
 
 export async function initHelmLoadAndPatchDojo(): Promise<void> {
-  const logPrefix = `Helm: _package.initHelmPatchDojo()`;
+  const logPrefix = `Helm: _package.initHelmLoadAndPatchDojo()`;
   // patch window.dojox.gfx.svg.Text.prototype.getTextWidth hangs
   /** get the text width in pixels */
   const pi = DG.TaskBarProgressIndicator.create('Loading Helm Web Editor ...');
@@ -55,23 +59,23 @@ export async function initHelmLoadAndPatchDojo(): Promise<void> {
 
     // dojo.window','dojo.io.script','dojo.io.iframe','dojo.dom','dojox.gfx','dojox.gfx.svg','dojox.gfx.shape','dojox.charting'
     const dojoTargetList: { name: string, checker: () => boolean }[] = [
-      {name: 'dojo.window', checker: () => !!dojo?.window},
-      {name: 'dojo.ready', checker: () => !!dojo?.ready},
-      {name: 'dojo.io.script', checker: () => !!dojo?.io?.script},
-      {name: 'dojo.io.iframe', checker: () => !!dojo?.io?.iframe},
-      // {name: 'dojo.dom', checker: () => !!dojo?.dom},
-      {name: 'dojox.gfx', checker: () => !!dojox?.gfx},
-      {name: 'dojox.gfx.svg', checker: () => !!dojox?.gfx?.svg},
-      {name: 'dojox.gfx.createSurface', checker: () => !!dojox?.gfx?.createSurface},
-      {name: 'dojox.gfx.shape', checker: () => !!dojox?.gfx?.shape},
-      {name: 'dojox.storage.Provider', checker: () => !!dojox?.storage?.Provider},
-      {name: 'dojox.storage.LocalStorageProvider', checker: () => !!dojox?.storage?.LocalStorageProvider},
-      // {name: 'dojox.charting', checker: () => !!dojox.charting},
-      // {name: 'dojox.charting.themes.Claro', checker: () => !!dojox.charting?.themes?.Claro},
-      // {name: 'dojox.charting.themes.Wetland', checker: () => !!dojox.charting?.themes?.Wetland},
-      // {name: 'dojox.charting.plot2d.Base', checker: () => !!dojox.charting?.plot2d?.Base},
-      // {name: 'dojox.charting.Series', checker: () => !!dojox?.charting?.Series},
-      // {name: 'dojox.charting.Chart2D', checker: () => !!dojox?.charting?.Chart2D},
+      {name: 'dojo.window', checker: () => !!(window.dojo?.window)},
+      {name: 'dojo.ready', checker: () => !!(window.dojo?.ready)},
+      {name: 'dojo.io.script', checker: () => !!(window.dojo?.io?.script)},
+      {name: 'dojo.io.iframe', checker: () => !!(window.dojo?.io?.iframe)},
+      // {name: 'dojo.dom', checker: () => !!(window.dojo?.dom)},
+      {name: 'dojox.gfx', checker: () => !!(window.dojox?.gfx)},
+      {name: 'dojox.gfx.svg', checker: () => !!(window.dojox?.gfx?.svg)},
+      {name: 'dojox.gfx.createSurface', checker: () => !!(window.dojox?.gfx?.createSurface)},
+      {name: 'dojox.gfx.shape', checker: () => !!(window.dojox?.gfx?.shape)},
+      {name: 'dojox.storage.Provider', checker: () => !!(window.dojox?.storage?.Provider)},
+      {name: 'dojox.storage.LocalStorageProvider', checker: () => !!(window.dojox?.storage?.LocalStorageProvider)},
+      // {name: 'dojox.charting', checker: () => !!(window.dojox.charting)},
+      // {name: 'dojox.charting.themes.Claro', checker: () => !!(window.dojox.charting?.themes?.Claro)},
+      // {name: 'dojox.charting.themes.Wetland', checker: () => !!(window.dojox.charting?.themes?.Wetland)},
+      // {name: 'dojox.charting.plot2d.Base', checker: () => !!(window.dojox.charting?.plot2d?.Base)},
+      // {name: 'dojox.charting.Series', checker: () => !!(window.dojox?.charting?.Series)},
+      // {name: 'dojox.charting.Chart2D', checker: () => !!(window.dojox?.charting?.Chart2D)},
     ];
     /** Gets list ofd modules not ready yet */
     const getDojoNotReadyList = (): string[] => {
@@ -85,15 +89,30 @@ export async function initHelmLoadAndPatchDojo(): Promise<void> {
       await timeout(async () => {
         await new Promise<void>((resolve, reject) => {
           window.dojoConfig = {
+            baseUrl: '/dojo',
             callback: () => { resolve(); },
-            parseOnLoad: true,
-            async: false,
+            parseOnLoad: false,
+            async: true,
             locale: 'en-us', // to limit dijit/nls file set
+            loaderPatch: {
+              injectUrl: (url: string, callback: any, owner: any) => {
+                const logPrefixInt = `${logPrefix} dojoConfig.loaderPatch.injectUrl()`;
+                _package.logger.debug(`${logPrefixInt}, url: ${url}`);
+                try {
+                  const bundledFn = `.${url}${window.dojo$.uncompressed}`;
+                  window.dojo$.ctx(bundledFn);
+                  callback();
+                } catch (err: any) {
+                  _package.logger.warning(`${logPrefixInt}: not loaded url: '${url}'.`);
+                }
+              },
+            },
           };
           // Load dojo without package/sources section for the settings dojoConfig to take effect
           DG.Utils.loadJsCss([
             // 'https://ajax.googleapis.com/ajax/libs/dojo/1.10.4/dojo/dojo.js.uncompressed.js',
-            `${_package.webRoot}/vendor/dojo-1.10.10/dojo/dojo.js.uncompressed.js`,
+            // `${_package.webRoot}/vendor/dojo-1.10.10/dojo/dojo.js.uncompressed.js`,
+            `${_package.webRoot}/dist/package-dojo.js`,
           ]).then(() => {});
         });
 

package/src/package.ts

@@ -6,23 +6,17 @@ import * as DG from 'datagrok-api/dg';
 import $ from 'cash-dom';
 
 import {testEvent} from '@datagrok-libraries/utils/src/test';
-import {errorToConsole} from '@datagrok-libraries/utils/src/to-console';
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
-import {IMonomerLib} from '@datagrok-libraries/bio/src/types';
 import {App, Editor, HelmMol, HelmType, HweWindow} from '@datagrok-libraries/bio/src/helm/types';
 import {HelmInputBase, IHelmHelper, IHelmInputInitOptions} from '@datagrok-libraries/bio/src/helm/helm-helper';
 import {HelmServiceBase} from '@datagrok-libraries/bio/src/viewers/helm-service';
 import {getMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 
-import {HelmCellRenderer} from './cell-renderer';
-import {HelmHelper} from './helm-helper';
 import {getPropertiesWidget} from './widgets/properties-widget';
 import {HelmGridCellRenderer, HelmGridCellRendererBack} from './utils/helm-grid-cell-renderer';
 import {_getHelmService, HelmPackage, initHelmLoadAndPatchDojo} from './package-utils';
-import {RGROUP_CAP_GROUP_NAME, RGROUP_LABEL, SMILES} from './constants';
-import {getRS} from './utils/get-monomer-dummy';
 
 // Do not import anything than types from @datagrok/helm-web-editor/src/types
 import type {JSDraw2Module, OrgHelmModule, ScilModule} from './types';
@@ -42,8 +36,17 @@ declare const scil: ScilModule;
 declare const JSDraw2: JSDraw2Module;
 declare const org: OrgHelmModule;
 
+let initHelmPromise: Promise<void> | null = null;
+
 //tags: init
 export async function initHelm(): Promise<void> {
+  if (initHelmPromise === null) {
+    initHelmPromise = initHelmInt();
+  }
+  await initHelmPromise;
+}
+
+async function initHelmInt(): Promise<void> {
   const logPrefix: string = 'Helm: _package.initHelm()';
   _package.logger.debug(`${logPrefix}, start`);
 
@@ -79,7 +82,7 @@ export function getHelmService(): HelmServiceBase {
 //meta.cellType: helm
 //meta.columnTags: quality=Macromolecule, units=helm
 //output: grid_cell_renderer result
-export function helmCellRenderer(): HelmCellRenderer {
+export function helmCellRenderer(): DG.GridCellRenderer {
   const logPrefix = `Helm: _package.getHelmCellRenderer()`;
   _package.logger.debug(`${logPrefix}, start`);
   // return new HelmCellRenderer(); // old
@@ -189,7 +192,7 @@ export async function getHelmHelper(): Promise<IHelmHelper> {
 export async function measureCellRenderer(): Promise<void> {
   const grid = grok.shell.tv.grid;
   const gridCol = grid.columns.byName('sequence')!;
-  const back = gridCol.temp['rendererBack'] as HelmGridCellRendererBack;
+  const back = gridCol.temp.rendererBack as HelmGridCellRendererBack;
 
   let etSum: number = 0;
   let etCount: number = 0;
@@ -217,3 +220,27 @@ export async function measureCellRenderer(): Promise<void> {
   }
   _package.logger.info(`measureCellRenderer(), avg ET: ${etSum / etCount} ms`);
 }
+
+// -- Test apps --
+
+//name: Highlight Monomers
+//tags: app
+//output: view result
+export async function highlightMonomers(): Promise<void> {
+  const pi = DG.TaskBarProgressIndicator.create('Test app highlight monomers');
+  try {
+    const df = await _package.files.readCsv('tests/peptide.csv');
+    df.name = 'peptide.csv';
+    await initHelmPromise;
+
+    const seqCol = df.columns.byName('helm')!;
+    await grok.data.detectSemanticTypes(df);
+    await grok.functions.call('Bio:toAtomicLevel', {table: df, seqCol: seqCol, nonlinear: true, highlight: true});
+
+    // const resView = DG.TableView.create(df, false);
+    // return resView;
+    grok.shell.addTableView(df);
+  } finally {
+    pi.close();
+  }
+}

package/src/tests/get-monomer-tests.ts

@@ -7,10 +7,10 @@ import wu from 'wu';
 import {
   after, before, category, delay, expect, test, expectArray, testEvent, expectFloat, timeout
 } from '@datagrok-libraries/utils/src/test';
-import {getHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
+import {getHelmHelper, getMonomerHandleArgs} from '@datagrok-libraries/bio/src/helm/helm-helper';
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
-import {Atom, HelmType, IJsAtom, IWebEditorMonomer, GetMonomerFunc} from '@datagrok-libraries/bio/src/helm/types';
-import {IMonomerLib, Monomer, MonomerLibSummaryType} from '@datagrok-libraries/bio/src/types';
+import {Atom, HelmType, IJsAtom, GetMonomerFunc} from '@datagrok-libraries/bio/src/helm/types';
+import {MonomerLibSummaryType} from '@datagrok-libraries/bio/src/types';
 import {IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
@@ -19,12 +19,9 @@ import {
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {defaultMonomerLibSummary, expectMonomerLib} from '@datagrok-libraries/bio/src/tests/monomer-lib-tests';
 
-import {getMonomerHandleArgs, rewriteLibraries} from '../utils/get-monomer';
+import {rewriteLibraries} from '../utils/get-monomer';
 import {JSDraw2Module, OrgHelmModule} from '../types';
 
-import {HelmHelper} from '../helm-helper';
-import {RGROUP_CAP_GROUP_NAME, RGROUP_LABEL, SMILES} from '../constants';
-import {getRS} from '../utils/get-monomer-dummy';
 import {initHelmMainPackage} from './utils';
 
 import {_package} from '../package-test';
@@ -71,9 +68,7 @@ const tests: { [testName: string]: TestDataType } = {
 };
 
 category('getMonomer', ()=>{
-  let libHelper: IMonomerLibHelper;
   let helmHelper: IHelmHelper;
-
   let monomerLibHelper: IMonomerLibHelper;
   /** Backup actual user's monomer libraries settings */
   let userLibSettings: UserLibSettings;
@@ -81,20 +76,12 @@ category('getMonomer', ()=>{
   before(async ()=>{
     await initHelmMainPackage();
 
-    [libHelper, helmHelper] = await Promise.all([getMonomerLibHelper(), getHelmHelper()]);
-
-    await timeout(async () => { monomerLibHelper = await getMonomerLibHelper(); }, 5000,
-      'get monomerLibHelper');
-    await timeout(async () => { userLibSettings = await getUserLibSettings(); }, 5000,
-      'get user lib settings for backup');
+    [monomerLibHelper, helmHelper, userLibSettings] = await Promise.all(
+      [getMonomerLibHelper(), getHelmHelper(), getUserLibSettings()]);
 
-    // Tests 'findMonomers' requires default monomer library loaded
-    await timeout(async () => { await setUserLibSettingsForTests(); }, 5000,
-      'set user lib settings for tests');
-    await timeout(async ()=> { await monomerLibHelper.awaitLoaded(); }, 5000,
-      'await monomerLib to be loaded');
-    await timeout(async () => { await monomerLibHelper.loadMonomerLib(true); }, 5000,
-      'reload monomerLib with settings for tests'); // load default libraries for tests
+    await setUserLibSettingsForTests();
+    await monomerLibHelper.awaitLoaded();
+    await monomerLibHelper.loadMonomerLib(true); // load default libraries for tests
   });
 
   after(async ()=>{
@@ -103,7 +90,7 @@ category('getMonomer', ()=>{
   });
 
   test('original', async () =>{
-    const monomerLib = libHelper.getMonomerLib();
+    const monomerLib = monomerLibHelper.getMonomerLib();
     rewriteLibraries(monomerLib);
 
     // const overriddenMonomersFuncs = helmHelper.revertOriginalMonomersFuncs();

package/src/tests/helm-helper-tests.ts

@@ -0,0 +1,94 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {after, before, category, delay, expect, expectArray, test, testEvent} from '@datagrok-libraries/utils/src/test';
+import {HelmNotSupportedError, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
+import {getHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
+
+import {_package} from '../package-test';
+
+type TestSrcType = { helm: string };
+type TestTgtType = { helm: string | null, map: [number, number][] };
+
+category('HelmHelper: removeGaps', () => {
+  let helmHelper: IHelmHelper;
+
+  before(async () => {
+    helmHelper = await getHelmHelper();
+  });
+
+  const tests: { [testName: string]: { src: TestSrcType, tgt: TestTgtType } } = {
+    'single-linear-start': {
+      src: {helm: 'PEPTIDE1{*.[meY].A.G.T}$$$$V2.0'},
+      tgt: {
+        helm: 'PEPTIDE1{[meY].A.G.T}$$$$V2.0',
+        map: [[1, 0], [2, 1], [3, 2], [4, 3]],
+      }
+    },
+    'single-linear-end': {
+      src: {helm: 'PEPTIDE1{[meY].A.G.T.*}$$$$V2.0'},
+      tgt: {
+        helm: 'PEPTIDE1{[meY].A.G.T}$$$$V2.0',
+        map: [[0, 0], [1, 1], [2, 2], [3, 3]],
+      }
+    },
+    'single-linear-middle': {
+      src: {helm: 'PEPTIDE1{[meY].A.*.G.T}$$$$V2.0'},
+      tgt: {
+        helm: 'PEPTIDE1{[meY].A.G.T}$$$$V2.0',
+        map: [[0, 0], [1, 1], [3, 2], [4, 3]],
+      }
+    },
+    'single-cycle-start': {
+      src: {helm: 'PEPTIDE1{*.[meY].C.R.N.P.C.T}$PEPTIDE1,PEPTIDE1,3:R3-7:R3$$$V2.0'},
+      tgt: {
+        helm: 'PEPTIDE1{[meY].C.R.N.P.C.T}$PEPTIDE1,PEPTIDE1,2:R3-6:R3$$$V2.0',
+        map: [[1, 0], [2, 1], [3, 2], [4, 3], [5, 4], [6, 5], [7, 6]],
+      }
+    },
+    'single-cycle-end': {
+      src: {helm: 'PEPTIDE1{[meY].C.R.N.P.C.T.*}$PEPTIDE1,PEPTIDE1,2:R3-6:R3$$$V2.0'},
+      tgt: {
+        helm: 'PEPTIDE1{[meY].C.R.N.P.C.T}$PEPTIDE1,PEPTIDE1,2:R3-6:R3$$$V2.0',
+        map: [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4], [5, 5], [6, 6]],
+      }
+    },
+    'single-cycle-middle': {
+      src: {helm: 'PEPTIDE1{[meY].C.R.N.*.P.C.T}$PEPTIDE1,PEPTIDE1,2:R3-7:R3$$$V2.0'},
+      tgt: {
+        helm: 'PEPTIDE1{[meY].C.R.N.P.C.T}$PEPTIDE1,PEPTIDE1,2:R3-6:R3$$$V2.0',
+        map: [[0, 0], [1, 1], [2, 2], [3, 3], [5, 4], [6, 5], [7, 6]],
+      }
+    },
+    'single-cycle-gap-at-connection': {
+      src: {helm: 'PEPTIDE1{[meY].*.C.R.N.P.C.T}$PEPTIDE1,PEPTIDE1,2:R3-7:R3$$$V2.0'},
+      tgt: {helm: null, map: []}
+    }
+  };
+
+  for (const [testName, testData] of Object.entries(tests)) {
+    test(`${testName}`, async () => {
+      let resErr: any = null;
+      try {
+        const res = helmHelper.removeGaps(testData.src.helm);
+        expect(res.resHelm, testData.tgt.helm);
+        expectArray(Array.from(res.monomerMap!.entries()), testData.tgt.map);
+      } catch (err: any) {
+        resErr = err;
+      }
+
+      if (testData.tgt.helm === null) { // err expected, for debug on GitHub CI
+        expect(resErr != null, true, 'Error expected');
+        const isErrorInstance = resErr instanceof HelmNotSupportedError;
+        const errCtorName = resErr.constructor.name;
+        const isErrorCtor = errCtorName === 'HelmNotSupportedError';
+        _package.logger.debug(`Check error object. ` +
+          `isErrorInstance: ${isErrorInstance}, isErrorCtor: ${isErrorCtor}, errCtorName: ${errCtorName}`);
+      }
+
+      expect((resErr instanceof HelmNotSupportedError) || resErr?.constructor.name === 'HelmNotSupportedError',
+        testData.tgt.helm === null, 'HelmNotSupportedError thrown expected');
+    }, testData.tgt.helm == null ? {skipReason: 'GitHub CI does not support testing exceptions'} : undefined);
+  }
+});