@datagrok/helm 2.5.5 → 2.5.6

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@datagrok/helm",
   "friendlyName": "Helm",
-  "version": "2.5.5",
+  "version": "2.5.6",
   "author": {
     "name": "Aleksandr Tanas",
     "email": "atanas@datagrok.ai"
@@ -16,7 +16,7 @@
     "css/helm.css"
   ],
   "dependencies": {
-    "@datagrok-libraries/bio": "^5.45.0",
+    "@datagrok-libraries/bio": "^5.45.4",
     "@datagrok-libraries/chem-meta": "^1.2.7",
     "@datagrok-libraries/utils": "^4.3.6",
     "cash-dom": "^8.1.1",
@@ -29,7 +29,7 @@
   "devDependencies": {
     "@datagrok-libraries/helm-web-editor": "^1.1.12",
     "@datagrok-libraries/js-draw-lite": "^0.0.9",
-    "@datagrok/bio": "^2.16.0",
+    "@datagrok/bio": "^2.16.6",
     "@datagrok/chem": "^1.12.3",
     "@types/node": "17.0.45",
     "@types/webpack-env": "^1.18.5",
@@ -79,4 +79,4 @@
     "directory": "packages/Helm"
   },
   "category": "Bioinformatics"
-}
+}

package/src/global.d.ts

@@ -0,0 +1,13 @@
+import * as grokNamespace from 'datagrok-api/grok';
+import * as uiNamespace from 'datagrok-api/ui';
+import * as DGNamespace from 'datagrok-api/dg';
+import * as rxjsNamespace from 'rxjs';
+import $Namespace from 'cash-dom';
+
+declare global {
+    const grok: typeof grokNamespace;
+    const ui: typeof uiNamespace;
+    const DG: typeof DGNamespace;
+    const rjxs: typeof rxjsNamespace;
+    const $: typeof $Namespace;
+}

package/src/package-test.ts

@@ -14,7 +14,6 @@ import './tests/helm-service-tests';
 import './tests/renderers-tests';
 import './tests/get-molfiles-tests';
 import './tests/properties-widget-tests';
-import './tests/get-all-parts-tests';
 import './tests/get-monomer-tests';
 import './tests/parse-helm-tests';
 import './tests/helm-web-editor-tests';

package/src/package-utils.ts

@@ -59,6 +59,7 @@ export async function initHelmLoadAndPatchDojo(): Promise<void> {
   try {
     const requireBackup = window.require;
 
+    // Dojo modules required by JDraw2 and HELMWebEditor
     // '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 }[] = [

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

@@ -6,6 +6,9 @@ import * as DG from 'datagrok-api/dg';
 import {after, before, category, delay, expect, expectArray, test, testEvent} from '@datagrok-libraries/utils/src/test';
 import {HelmNotSupportedError, HelmNotSupportedErrorType, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 import {getHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
+import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import {getUserLibSettings, setUserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
+import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 /* eslint-enable max-len */
 
 import {_package} from '../package-test';
@@ -15,9 +18,21 @@ type TestTgtType = { helm: string | null, map: [number, number][], errType?: str
 
 category('HelmHelper: removeGaps', () => {
   let helmHelper: IHelmHelper;
+  let libHelper: IMonomerLibHelper;
+  let userLibSettings: UserLibSettings;
 
   before(async () => {
     helmHelper = await getHelmHelper();
+    libHelper = await getMonomerLibHelper();
+
+    userLibSettings = await getUserLibSettings();
+    // Cysteine has different R-groups in other libraries
+    await libHelper.loadMonomerLibForTests();
+  });
+
+  after(async () => {
+    await setUserLibSettings(userLibSettings);
+    await libHelper.loadMonomerLib(true);
   });
 
   const tests: { [testName: string]: { src: TestSrcType, tgt: TestTgtType } } = {

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

@@ -10,6 +10,7 @@ import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 import {
   getUserLibSettings, setUserLibSettings
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
+import {IHelmHelper, getHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 
 import {JSDraw2Module} from '../types';
 import {initHelmMainPackage} from './utils';
@@ -37,10 +38,28 @@ category('parseHelm', () => {
     },
     'RNA': {
       src: 'RNA1{[dhp]([m1A])p.r(T)p.r(T)p.r(G)p}$$$$V2.0',
-      tgt: {atomCount: 12, bondCount: 11, helm: 'RNA1{[dhp]([m1A])p.r(T)p.r(T)p.r(G)p}$$$$V2.0',}
-    }
+      tgt: {
+        atomCount: 12, bondCount: 11,
+        helm: 'RNA1{[dhp]([m1A])p.r(T)p.r(T)p.r(G)p}$$$$V2.0',
+      }
+    },
+    'PT-with-gap': {
+      src: 'PEPTIDE1{[meY].*.C.R.N.P.C.T}$$$$V2.0',
+      tgt: {
+        atomCount: 8, bondCount: 7,
+        helm: 'PEPTIDE1{[meY].*.C.R.N.P.C.T}$$$$V2.0',
+      }
+    },
+    'PT-with-gap-at-connection': {
+      src: 'PEPTIDE1{[meY].*.C.R.N.P.C.T}$PEPTIDE1,PEPTIDE1,2:R3-7:R3$$$V2.0',
+      tgt: {
+        atomCount: 8, bondCount: 8,
+        helm: 'PEPTIDE1{[meY].*.C.R.N.P.C.T}$PEPTIDE1,PEPTIDE1,2:R3-7:R3$$$V2.0',
+      }
+    },
   };
 
+  let helmHelper: IHelmHelper;
   let libHelper: IMonomerLibHelper;
   /** Backup actual user's monomer libraries settings */
   let userLibSettings: UserLibSettings;
@@ -48,8 +67,9 @@ category('parseHelm', () => {
   before(async () => {
     await initHelmMainPackage();
 
-    libHelper = await getMonomerLibHelper();
+    helmHelper = await getHelmHelper();
 
+    libHelper = await getMonomerLibHelper();
     userLibSettings = await getUserLibSettings();
 
     // parseHelm is dependent on monomers RGroups available, test requires default monomer library
@@ -67,6 +87,12 @@ category('parseHelm', () => {
     });
   }
 
+  for (const [testName, {src, tgt}] of Object.entries(testData)) {
+    test(`HelmHelper-${testName}`, async () => {
+      _testParseHelmWithHelmHelper(src, tgt, helmHelper);
+    });
+  }
+
   for (const [testName, {src, tgt}] of Object.entries(testData)) {
     test(`woDOM-${testName}`, async () => {
       _testParseHelmWithoutDOM(src, tgt);
@@ -89,6 +115,20 @@ function _testParseHelmWithEditor(src: string, tgt: TestTgtType): void {
   expect(m.bonds.length, tgt.bondCount);
 }
 
+function _testParseHelmWithHelmHelper(src: string, tgt: TestTgtType, helmHelper: IHelmHelper): void {
+  const io = org.helm.webeditor.IO;
+
+  const origin = new JSDraw2.Point(0, 0);
+  const resMol = helmHelper.parse(src, origin);
+
+  const resHelm = io.getHelm(resMol);
+  expect(resMol.atoms.length, tgt.atomCount);
+  expect(resMol.bonds.length, tgt.bondCount);
+  expect(resHelm, tgt.helm);
+  expect(resMol.atoms.every((a) => !a.elem.startsWith('[') && !a.elem.endsWith(']')), true,
+    'Atoms should not contain square braces.');
+}
+
 function _testParseHelmWithoutDOM(src: string, tgt: TestTgtType): void {
   const io = org.helm.webeditor.IO;
 
@@ -103,5 +143,6 @@ function _testParseHelmWithoutDOM(src: string, tgt: TestTgtType): void {
   expect(m.atoms.length, tgt.atomCount);
   expect(m.bonds.length, tgt.bondCount);
   expect(resHelm, tgt.helm);
-  expect(m.atoms.every((a) => !a.elem.startsWith('[') && !a.elem.endsWith(']')), true, 'Atoms should not contain square braces.');
+  expect(m.atoms.every((a) => !a.elem.startsWith('[') && !a.elem.endsWith(']')), true,
+    'Atoms should not contain square braces.');
 }

package/src/utils/get-hovered.ts

@@ -9,8 +9,6 @@ import {helmTypeToPolymerType} from '@datagrok-libraries/bio/src/monomer-works/m
 import {HelmTypes} from '@datagrok-libraries/bio/src/helm/consts';
 import {GAP_SYMBOL, GapOriginals, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
 
-import {HelmMonomerPlacer} from '../helm-monomer-placer';
-
 export function getHoveredMonomerFromEditorMol(
   argsX: number, argsY: number, mol: HelmMol, cellHeight?: number
 ): HelmAtom | null {
@@ -49,41 +47,6 @@ export function getHoveredMonomerFromEditorMol(
   return resAtom;
 }
 
-export function getHoveredMonomerFallback(
-  argsX: number, _argsY: number, gridCell: DG.GridCell, helmPlacer: HelmMonomerPlacer
-): ISeqMonomer | null {
-  let hoveredSeqMonomer: ISeqMonomer | null = null;
-  const [allParts, lengths, sumLengths] = helmPlacer.getCellAllPartsLengths(gridCell.tableRowIndex!);
-  const maxIndex = Object.values(lengths).length - 1;
-  let left = 0;
-  let right = maxIndex;
-  let found = false;
-  let iterCount: number = 0;
-
-  let mid = 0;
-  if (argsX > sumLengths[0]) {
-    while (!found && iterCount < sumLengths.length) {
-      mid = Math.floor((right + left) / 2);
-      if (argsX >= sumLengths[mid] && argsX <= sumLengths[mid + 1]) {
-        left = mid;
-        found = true;
-      } else if (argsX < sumLengths[mid])
-        right = mid - 1;
-      else if (argsX > sumLengths[mid + 1])
-        left = mid + 1;
-
-      if (left == right)
-        found = true;
-
-      iterCount++;
-    }
-  }
-  left = (argsX >= sumLengths[left]) ? left : left - 1; // correct left to between sumLengths
-  if (left >= 0)
-    hoveredSeqMonomer = getSeqMonomerFromHelm(left, allParts[left], allParts[0]);
-  return hoveredSeqMonomer;
-}
-
 export function getSeqMonomerFromHelmAtom(atom: HelmAtom): ISeqMonomer {
   const canonicalSymbol = atom.elem === GapOriginals[NOTATION.HELM] ? GAP_SYMBOL : atom.elem;
   return {position: parseInt(atom.bio!.continuousId as string) - 1, symbol: canonicalSymbol, biotype: atom.bio!.type};

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

@@ -94,48 +94,62 @@ export class HelmGridCellRendererBack extends CellRendererBackAsyncBase<HelmProp
   protected override renderCellImageData(
     gridCtx: CanvasRenderingContext2D, gridCellBounds: DG.Rect, gridCell: DG.GridCell, cellImageData: ImageData,
   ): boolean {
+    // super.renderCellImageData(gridCtx, gridCellBounds, gridCell, cellImageData);
+    // return true;
+
+    const gcb = gridCellBounds;
     const dpr = window.devicePixelRatio;
     if (gridCell.tableRowIndex === null) return false;
     const aux = this._auxList[gridCell.tableRowIndex];
     if (!aux) return true;
 
+    const [cellWidth, cellHeight] = [gcb.width * dpr - 2, gcb.height * dpr - 2];
+    const cellDScale = Math.min(0.95 * cellWidth / aux.dBox.width, 0.95 * cellHeight / aux.dBox.height);
+    const [cellDWidth, cellDHeight] = [cellDScale * aux.dBox.width, cellDScale * aux.dBox.height];
+    const cellDBox = new DG.Rect((cellWidth - cellDWidth) / 2, (cellHeight - cellDHeight) / 2, cellDWidth, cellDHeight);
+
+
     // Draw cell image data to scale it with drawImage() while transform()
     const cellCanvas = ui.canvas(cellImageData.width, cellImageData.height);
     const cellCtx = cellCanvas.getContext('2d')!;
     cellCtx.putImageData(cellImageData, 0, 0);
 
-    // Get bbox canvas
-    const bBoxImageData = cellCtx.getImageData(aux.bBox.x, aux.bBox.y, aux.bBox.width, aux.bBox.height);
-    const bBoxCanvas = ui.canvas(aux.bBox.width, aux.bBox.height);
-    const bBoxCtx = bBoxCanvas.getContext('2d')!;
-    bBoxCtx.putImageData(bBoxImageData, 0, 0);
-
+    // // Get bbox canvas
+    // const bBoxImageData = cellCtx.getImageData(aux.bBox.x, aux.bBox.y, aux.bBox.width, aux.bBox.height);
+    // const bBoxCanvas = ui.canvas(aux.bBox.width, aux.bBox.height);
+    // const bBoxCtx = bBoxCanvas.getContext('2d')!;
+    // bBoxCtx.putImageData(bBoxImageData, 0, 0);
+    //
     const fitCanvasWidth = gridCellBounds.width * dpr - 2;
     const fitCanvasHeight = gridCellBounds.height * dpr - 2;
-
-    const bBoxRatio = Math.max(aux.bBox.width / aux.cBox.width, aux.bBox.height / aux.cBox.height);
-    const bBoxFullWidth = aux.bBox.width / bBoxRatio;
-    const bBoxFullHeight = aux.bBox.height / bBoxRatio;
-
-    const fitScale = Math.min(fitCanvasWidth / bBoxFullWidth, fitCanvasHeight / bBoxFullHeight);
-
-    // Relative shift of bbox center to cbox center
-    const bBoxShiftHR = (aux.bBox.left + aux.bBox.width / 2 - aux.cBox.width / 2) / aux.cBox.width;
-    const bBoxShiftVR = (aux.bBox.top + aux.bBox.height / 2 - aux.cBox.height / 2) / aux.cBox.height;
-
-    const bBoxFitLeft = fitCanvasWidth / 2 - bBoxCanvas.width * fitScale * (1 - 2 * bBoxShiftHR) / 2;
-    const bBoxFitTop = fitCanvasHeight / 2 - bBoxCanvas.height * fitScale * (1 - 2 * bBoxShiftVR) / 2;
-
+    //
+    // const bBoxRatio = Math.max(aux.bBox.width / aux.cBox.width, aux.bBox.height / aux.cBox.height);
+    // const bBoxFullWidth = aux.bBox.width / bBoxRatio;
+    // const bBoxFullHeight = aux.bBox.height / bBoxRatio;
+    //
+    // const fitScale = Math.min(fitCanvasWidth / bBoxFullWidth, fitCanvasHeight / bBoxFullHeight);
+    //
+    // // Relative shift of bbox center to cbox center
+    // const bBoxShiftHR = (aux.bBox.left + aux.bBox.width / 2 - aux.cBox.width / 2) / aux.cBox.width;
+    // const bBoxShiftVR = (aux.bBox.top + aux.bBox.height / 2 - aux.cBox.height / 2) / aux.cBox.height;
+    //
+    // const bBoxFitLeft = fitCanvasWidth / 2 - bBoxCanvas.width * fitScale * (1 - 2 * bBoxShiftHR) / 2;
+    // const bBoxFitTop = fitCanvasHeight / 2 - bBoxCanvas.height * fitScale * (1 - 2 * bBoxShiftVR) / 2;
+    //
     const fitCanvas = ui.canvas(fitCanvasWidth, fitCanvasHeight);
     const fitCtx = fitCanvas.getContext('2d')!;
     // fitCtx.fillStyle = '#FFFFA0';
     // fitCtx.fillRect(0, 0, fitCanvasWidth, fitCanvasHeight);
-    fitCtx.transform(fitScale, 0, 0, fitScale, bBoxFitLeft, bBoxFitTop);
-    fitCtx.drawImage(bBoxCanvas, 0, 0); // draw with scale transform
+    // fitCtx.transform(fitScale, 0, 0, fitScale, bBoxFitLeft, bBoxFitTop);
+    // fitCtx.drawImage(bBoxCanvas, 0, 0); // draw with scale transform
+    fitCtx.drawImage(cellCanvas,
+      aux.dBox.x, aux.dBox.y, aux.dBox.width, aux.dBox.height,
+      cellDBox.x, cellDBox.y, cellDBox.width, cellDBox.height);
 
     const fitCanvasData = fitCtx.getImageData(0, 0, fitCanvasWidth, fitCanvasHeight);
     this.renderOnGrid(gridCtx, gridCellBounds, gridCell, fitCanvasData);
-    return true; // request rendering
+
+    return aux.cBox.width != cellWidth || aux.cBox.height != cellHeight; // request rendering
   }
 
   onMouseMove(gridCell: DG.GridCell, e: MouseEvent): void {
@@ -147,15 +161,18 @@ export class HelmGridCellRendererBack extends CellRendererBackAsyncBase<HelmProp
     const dpr = window.devicePixelRatio;
 
     /** {@link gridCell}.bounds */ const gcb = gridCell.bounds;
-    const argsX = (e.offsetX - gcb.x) * dpr;
-    const argsY = (e.offsetY - gcb.y) * dpr;
+    const cX = (e.offsetX - gcb.x) * dpr;
+    const cY = (e.offsetY - gcb.y) * dpr;
+
+    const bX = aux.bBox.x + (cX - aux.dBox.x) * aux.bBox.width / aux.dBox.width;
+    const bY = aux.bBox.y + (cY - aux.dBox.y) * aux.bBox.height / aux.dBox.height;
 
-    const editorMol: Mol<HelmType> | null = aux.mol;
+    const editorMol: Mol<HelmType> | null = aux.mol; // in bBox world
     if (!editorMol) {
       this.logger.warning(`${logPrefix}, editorMol of the cell not found.`);
       return; // The gridCell is not rendered yet
     }
-    const hoveredAtom = getHoveredMonomerFromEditorMol(argsX, argsY, editorMol, gridCell.bounds.height);
+    const hoveredAtom = getHoveredMonomerFromEditorMol(bX, bY, editorMol, gridCell.bounds.height);
 
     let seqMonomer: ISeqMonomer | null = null;
     if (hoveredAtom) {

package/src/utils/helm-service.ts

@@ -1,4 +1,3 @@
-import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
@@ -89,15 +88,19 @@ export class HelmService extends HelmServiceBase {
     if (!helmStr)
       editor.reset();
 
-    const bBox = (editor.div.children[0] as SVGSVGElement).getBBox();
+    const svgEl = editor.div.children[0] as SVGSVGElement;
+    const bBox = svgEl.getBBox();
+    const [cellWidth, cellHeight] = [task.props.width, task.props.height];
+    const bScale = Math.min(cellWidth * 0.95 / bBox.width, cellHeight * 0.95 / bBox.height);
+    const [drawWidth, drawHeight] = [bBox.width * bScale, bBox.height * bScale];
     const aux: HelmAux = {
       mol: editor.m.clone(false),
       bBox: new DG.Rect(bBox.x, bBox.y, bBox.width + 2, bBox.height + 2) /* adjust for clipping right/bottom */,
+      dBox: new DG.Rect((cellWidth - drawWidth) / 2, (cellHeight - drawHeight) / 2, drawWidth, drawHeight),
       cBox: new DG.Rect(0, 0, task.props.width, task.props.height),
     };
     const lET = window.performance.now();
 
-    const svgEl = $(this.hostDiv).find('svg').get(0) as unknown as SVGSVGElement;
     const dpr = window.devicePixelRatio;
 
     const rST = window.performance.now();
@@ -135,7 +138,9 @@ export class HelmService extends HelmServiceBase {
       if (!this.image || !g) return false;
       // g.fillStyle = '#C0C0FF';
       // g.fillRect(0, 0, canvas.width, canvas.height);
-      g.drawImage(this.image, 0, 0);
+      g.drawImage(this.image,
+        aux.bBox.x, aux.bBox.y, aux.bBox.width, aux.bBox.height,
+        aux.dBox.x, aux.dBox.y, aux.dBox.width, aux.dBox.height);
       task.onAfterRender(canvas, aux);
     } finally {
       canvas.remove();

package/src/helm-monomer-placer.ts

@@ -1,98 +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 {HelmType, Mol, PolymerType} from '@datagrok-libraries/bio/src/helm/types';
-
-import {CellRendererBackBase} from '@datagrok-libraries/bio/src/utils/cell-renderer-back-base';
-
-import {getParts, parseHelm} from './utils';
-
-import {_package} from './package';
-
-export class HelmMonomerPlacer extends CellRendererBackBase<string> {
-  private _allPartsList: (string[] | null)[];
-  private _lengthsList: (number[] | null)[];
-  private _editorMolList: (Mol<HelmType> | null)[];
-
-  public monomerCharWidth: number = 7;
-  public leftPadding: number = 5;
-  public monomerTextSizeMap: { [p: string]: TextMetrics } = {};
-
-  public constructor(
-    gridCol: DG.GridColumn | null,
-    tableCol: DG.Column<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);
-    this._editorMolList = new Array<Mol<HelmType> | null>(this.tableCol.length).fill(null);
-  }
-
-  /** Skips cell for the fallback rendering */
-  public skipCell(rowIdx: number): void {
-    this._allPartsList[rowIdx] = [];
-    this._lengthsList[rowIdx] = [];
-  }
-
-  /** @param rowIdx Row index of the table {@link DG.DataFrame}, HelmMonomerPlacer is {@link DG.Column} based */
-  public getCellAllPartsLengths(rowIdx: number): [string[], number[], number[]] {
-    const [allParts, lengths] = this.getCellMonomerLengthsForSeq(rowIdx);
-
-    const sumLengths: number[] = new Array<number>(lengths.length + 1);
-    sumLengths[0] = this.leftPadding; // padding
-    for (let pos: number = 1; pos < sumLengths.length; pos++)
-      sumLengths[pos] = sumLengths[pos - 1] + lengths[pos - 1];
-    return [allParts, lengths, sumLengths];
-  }
-
-  private getCellMonomerLengthsForSeq(rowIdx: number): [string[], number[]] {
-    let allParts: string[] | null = this._allPartsList![rowIdx];
-    if (allParts === null) {
-      const seq = this.tableCol.get(rowIdx);
-      allParts = this._allPartsList![rowIdx] = getAllParts(seq);
-    }
-
-    let lengths: number[] | null = this._lengthsList![rowIdx];
-    if (lengths === null) {
-      lengths = this._lengthsList![rowIdx] = new Array<number>(allParts.length);
-      for (const [part, partI] of wu.enumerate(allParts)) {
-        const partWidth: number = part.length * this.monomerCharWidth;
-        lengths[partI] = partWidth;
-      }
-    }
-
-    return [allParts, lengths];
-  }
-
-  // -- Handle events --
-
-  private monomerLibOnChanged(_value: any): void {
-    this.dirty = true;
-    this.invalidateGrid();
-  }
-
-  public setEditorMol(tableRowIndex: number, editorMol: Mol<HelmType>) {
-    this._editorMolList![tableRowIndex] = editorMol.clone(false);
-  }
-
-  public getEditorMol(tableRowIndex: number): Mol<HelmType> | null {
-    return this._editorMolList![tableRowIndex];
-  }
-}
-
-export function getAllParts(seq: string | null): string[] {
-  const monomerList: string[] = !!seq ? parseHelm(seq) : [];
-  return !!seq ? getParts(monomerList, seq) : [];
-}

package/src/tests/get-all-parts-tests.ts

@@ -1,39 +0,0 @@
-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, test, expectArray} from '@datagrok-libraries/utils/src/test';
-
-import {getAllParts} from '../helm-monomer-placer';
-import {initHelmMainPackage} from './utils';
-
-category('getAllParts', () => {
-  /** All parts of Helm string are required for fallback rendering. */
-
-  const tests: { [testName: string]: { tgt: string[]; seq: string } } = {
-    'peptideSimpleSingleChar': {
-      seq: 'PEPTIDE1{L.V.A}$$$$',
-      tgt: ['PEPTIDE1{', 'L', '.', 'V', '.', 'A', '}$$$$'],
-    },
-    'peptideSimpleMultiChar': {
-      seq: 'PEPTIDE1{[Ac].V.A}$$$$',
-      /* doubt joining square brackets to separator or notation is correct */
-      tgt: ['PEPTIDE1{[', 'Ac', '].', 'V', '.', 'A', '}$$$$'],
-    }
-  };
-
-  before(async () => {
-    await initHelmMainPackage();
-  });
-
-  for (const [testName, testData] of Object.entries(tests)) {
-    test(`${testName}`, async () => {
-      await _testAllParts(testData.seq, testData.tgt);
-    });
-  }
-});
-
-async function _testAllParts(seq: string | null, tgt: string[]): Promise<void> {
-  const res: string[] = getAllParts(seq);
-  expectArray(res, tgt);
-}