@datagrok/sequence-translator 1.3.12 → 1.3.14

package/src/polytool/pt-enumeration-helm.ts

@@ -2,7 +2,11 @@ import * as ui from 'datagrok-api/ui';
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 
-import {HelmType, JSDraw2ModuleType, OrgType, HelmAtom, HelmMol} from '@datagrok-libraries/bio/src/helm/types';
+import {
+  HelmType, HelmMol,
+  JSDraw2ModuleType, OrgType
+} from '@datagrok-libraries/bio/src/helm/types';
+
 
 import {Chain} from './pt-conversion';
 import {getAvailableMonomers} from './utils';
@@ -17,9 +21,14 @@ declare const org: OrgType;
 function polyToolEnumeratorCore(m: HelmMol, position: number, monomerList: string[]): HelmMol[] {
   const resMolList: HelmMol[] = new Array<HelmMol>(monomerList.length);
   for (let i = 0; i < monomerList.length; i++) {
-    const symbolName = monomerList[i];
-    const resM = resMolList[i] = m.clone();
-    resM.atoms[position].elem = symbolName;
+    const newSymbol = monomerList[i];
+    const resM = resMolList[i] = m.clone() as HelmMol;
+    const oldSymbol = resM.atoms[position].elem;
+    resM.atoms[position].elem = newSymbol;
+
+    const idOldSymbol = oldSymbol?.length > 1 ? `[${oldSymbol}]` : oldSymbol;
+    const idNewSymbol = newSymbol?.length > 1 ? `[${newSymbol}]` : newSymbol;
+    resM.name = `${m.name}-${idOldSymbol}${position + 1}${idNewSymbol}`;
   }
   return resMolList;
 }
@@ -29,46 +38,45 @@ function polyToolEnumeratorCore(m: HelmMol, position: number, monomerList: strin
  * @param  placeholders Placeholders by zero-based position key
  * @returns {string[]} List of enumerated molecules in Helm format
  */
-function getPtEnumeratorSingle(helm: string, placeholders: PolyToolPlaceholders): string[] {
-  const molHandler = new JSDraw2.MolHandler<HelmType>();
-  const plugin = new org.helm.webeditor.Plugin(molHandler);
-  const io = org.helm.webeditor.IO;
-
-  const origin = new JSDraw2.Point(0, 0);
-  io.parseHelm(plugin, helm, origin, undefined);
-
+function getPtEnumeratorSingle(m: HelmMol, placeholders: PolyToolPlaceholders): HelmMol[] {
   const coreResList: HelmMol[][] = Object.entries(placeholders)
-    .map(([p, monomerList]: [string, string[]]) => polyToolEnumeratorCore(molHandler.m, parseInt(p), monomerList));
+    .map(([p, monomerList]: [string, string[]]) => polyToolEnumeratorCore(m, parseInt(p), monomerList));
   const resMolList = coreResList.reduce((acc, posList) => acc.concat(posList), []);
-
-  const resHelmList = resMolList.map((m: HelmMol) => org.helm.webeditor.IO.getHelm(m)!);
-  return resHelmList;
+  return resMolList;
 }
 
-function getPtEnumeratorMatrix(helm: string, placeholders: PolyToolPlaceholders): string[] {
-  const molHandler = new JSDraw2.MolHandler<HelmType>();
-  const plugin = new org.helm.webeditor.Plugin(molHandler);
-  const io = org.helm.webeditor.IO;
-
-  const origin = new JSDraw2.Point(0, 0);
-  io.parseHelm(plugin, helm, origin, undefined);
-
-  let resMolList = [molHandler.m];
+function getPtEnumeratorMatrix(m: HelmMol, placeholders: PolyToolPlaceholders): HelmMol[] {
+  let resMolList = [m];
   for (const [p, monomerList] of Object.entries(placeholders)) {
     const pos: number = parseInt(p);
     const posResMolList: HelmMol[][] = resMolList.map((m: HelmMol) => polyToolEnumeratorCore(m, pos, monomerList));
     resMolList = posResMolList.reduce((acc, l) => acc.concat(l), []);
   }
-
-  const resHelmList = resMolList.map((m: HelmMol) => org.helm.webeditor.IO.getHelm(m)!);
-  return resHelmList;
+  return resMolList;
 }
 
-export function getPtEnumeratorHelm(helm: string, params: PolyToolEnumeratorParams): string[] {
+export function getPtEnumeratorHelm(helm: string, id: string, params: PolyToolEnumeratorParams): [string, string][] {
+  const molHandler = new JSDraw2.MolHandler<HelmType>();
+  const plugin = new org.helm.webeditor.Plugin(molHandler);
+  org.helm.webeditor.IO.parseHelm(plugin, helm, new JSDraw2.Point(0, 0), undefined);
+  const m = molHandler.m;
+  m.name = id;
+
+  let resMolList: HelmMol[];
   switch (params.type) {
-  case PolyToolEnumeratorTypes.Single:
-    return getPtEnumeratorSingle(helm, params.placeholders);
-  case PolyToolEnumeratorTypes.Matrix:
-    return getPtEnumeratorMatrix(helm, params.placeholders);
+  case PolyToolEnumeratorTypes.Single: {
+    resMolList = getPtEnumeratorSingle(molHandler.m, params.placeholders);
+    break;
+  }
+  case PolyToolEnumeratorTypes.Matrix: {
+    resMolList = getPtEnumeratorMatrix(molHandler.m, params.placeholders);
+    break;
+  }
   }
+
+  if (params.keepOriginal)
+    resMolList = [m, ...resMolList];
+
+  const resList = resMolList.map<[string, string]>((m: HelmMol) => { return [org.helm.webeditor.IO.getHelm(m)!, m.name!]; });
+  return resList;
 }

package/src/polytool/pt-placeholders-input.ts

@@ -2,6 +2,8 @@ import * as ui from 'datagrok-api/ui';
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 
+import {Unsubscribable} from 'rxjs';
+
 import {PolyToolPlaceholders} from './types';
 
 export class PolyToolPlaceholdersInput extends DG.JsInputBase<DG.DataFrame> {
@@ -34,6 +36,8 @@ export class PolyToolPlaceholdersInput extends DG.JsInputBase<DG.DataFrame> {
   private readonly gridHost: HTMLDivElement;
   public readonly grid: DG.Grid;
 
+  private subs: Unsubscribable[] = [];
+
   protected constructor(name: string | undefined, grid: DG.Grid, heightRowCount?: number) {
     super();
 
@@ -41,7 +45,7 @@ export class PolyToolPlaceholdersInput extends DG.JsInputBase<DG.DataFrame> {
 
     this.gridHost = ui.div([], {
       classes: 'ui-input-editor',
-      style: {width: '100%', height: '100%', marginTop: '-8px'},
+      style: {width: '100%', height: '100%', marginTop: '-8px', marginBottom: '8px', paddingBottom: '4px'},
     });
 
     this.grid = grid;
@@ -51,25 +55,34 @@ export class PolyToolPlaceholdersInput extends DG.JsInputBase<DG.DataFrame> {
       this.updateGridHeight(heightRowCount + 0.7);
     } else {
       this.updateGridHeight(this.grid.dataFrame.rowCount + 0.6);
-      this.grid.dataFrame.onRowsAdded
-        .subscribe(() => { this.updateGridHeight(this.grid.dataFrame.rowCount + 0.6); });
+      this.subs.push(this.grid.dataFrame.onRowsAdded
+        .subscribe(() => { this.updateGridHeight(this.grid.dataFrame.rowCount + 0.6); }));
     }
     this.grid.root.style.width = `100%`;
 
-    ui.onSizeChanged(this.grid.root).subscribe(() => {
+    this.subs.push(this.grid.dataFrame.onDataChanged.subscribe(() => {
+      this.fireChanged();
+    }));
+
+    this.subs.push(ui.onSizeChanged(this.grid.root).subscribe(() => {
       this.grid.columns.byIndex(2)!.width = this.grid.root.clientWidth - this.grid.horzScroll.root.offsetWidth -
         this.grid.columns.byIndex(0)!.width - this.grid.columns.byIndex(1)!.width - 10;
-    });
+    }));
 
     this.root.classList.add('ui-input-polytool-pos-grid');
     this.root.append(this.gridHost);
   }
 
+  detach(): void {
+    for (const sub of this.subs) sub.unsubscribe();
+  }
+
   public static async create(
-    name?: string, value?: DG.DataFrame, options?: {}, heightRowCount?: number
+    name?: string, options?: {}, heightRowCount?: number
   ): Promise<PolyToolPlaceholdersInput> {
-    const df: DG.DataFrame = value ?? DG.DataFrame.create(0);
+    const df: DG.DataFrame = DG.DataFrame.fromObjects([{Position: '', Monomers: ''}])!;
     const grid = (await df.plot.fromType(DG.VIEWER.GRID, options)) as DG.Grid;
+    grid.sort(['Position']);
     return new PolyToolPlaceholdersInput(name, grid, heightRowCount);
   }
 
@@ -82,8 +95,9 @@ export class PolyToolPlaceholdersInput extends DG.JsInputBase<DG.DataFrame> {
 
   // -- Handle events --
 
-  private rootOnSizeChanged(): void {
-
+  private gridRootOnSizeChanged(): void {
+    this.grid.columns.byIndex(2)!.width = this.grid.root.clientWidth - this.grid.horzScroll.root.offsetWidth -
+      this.grid.columns.byIndex(0)!.width - this.grid.columns.byIndex(1)!.width - 10;
   }
 }
 

package/src/polytool/types.ts

@@ -15,4 +15,6 @@ export type PolyToolEnumeratorParams = {
   type: PolyToolEnumeratorType;
   /** position key is zero-based */
   placeholders: PolyToolPlaceholders;
+  keepOriginal?: boolean;
+  trivialName?: boolean;
 }

package/src/tests/polytool-enumerate-tests.ts

@@ -6,9 +6,7 @@ import {before, after, category, expect, test, expectArray} from '@datagrok-libr
 import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 
 import {PolyToolEnumeratorParams, PolyToolEnumeratorTypes} from '../polytool/types';
-import {polyToolEnumerateHelm} from '../package';
 import {getPtEnumeratorHelm} from '../polytool/pt-enumeration-helm';
-import {HelmMol} from '@datagrok-libraries/bio/src/helm/types';
 
 category('PolyTool', () => {
   let helmHelper: IHelmHelper;
@@ -22,27 +20,46 @@ category('PolyTool', () => {
   });
 
   const tests: {
-    [testName: string]: { src: string, params: PolyToolEnumeratorParams, tgt: string[] }
+    [testName: string]: { src: string, params: PolyToolEnumeratorParams, tgt: [string, string][] }
   } = {
     'single1': {
-      src: 'PEPTIDE1{[Ac(1)].F.W.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$',
+      src: 'PEPTIDE1{[Ac(1)].F.W.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0',
       params: {
         type: PolyToolEnumeratorTypes.Single,
         placeholders: {
           [4]: ['K', 'P', 'F4COO'],
           [6]: ['Y', 'T'],
-        }
+        },
+      },
+      tgt: [
+        ['PEPTIDE1{[Ac(1)].F.W.G.K.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', '-P5K'],
+        ['PEPTIDE1{[Ac(1)].F.W.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', '-P5P'],
+        ['PEPTIDE1{[Ac(1)].F.W.G.[F4COO].L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', '-P5[F4COO]'],
+        ['PEPTIDE1{[Ac(1)].F.W.G.P.L.Y.[C(1)].G.[NH2]}$$$$V2.0', '-[Tic]7Y'],
+        ['PEPTIDE1{[Ac(1)].F.W.G.P.L.T.[C(1)].G.[NH2]}$$$$V2.0', '-[Tic]7T'],
+      ]
+    },
+    'single-with-original': {
+      src: 'PEPTIDE1{[Ac(1)].F.W.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0',
+      params: {
+        type: PolyToolEnumeratorTypes.Single,
+        placeholders: {
+          [4]: ['K', 'P', 'F4COO'],
+          [6]: ['Y', 'T'],
+        },
+        keepOriginal: true,
       },
       tgt: [
-        'PEPTIDE1{[Ac(1)].F.W.G.K.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0',
-        'PEPTIDE1{[Ac(1)].F.W.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0',
-        'PEPTIDE1{[Ac(1)].F.W.G.[F4COO].L.[Tic].[C(1)].G.[NH2]}$$$$V2.0',
-        'PEPTIDE1{[Ac(1)].F.W.G.P.L.Y.[C(1)].G.[NH2]}$$$$V2.0',
-        'PEPTIDE1{[Ac(1)].F.W.G.P.L.T.[C(1)].G.[NH2]}$$$$V2.0',
+        ['PEPTIDE1{[Ac(1)].F.W.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', ''],
+        ['PEPTIDE1{[Ac(1)].F.W.G.K.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', '-P5K'],
+        ['PEPTIDE1{[Ac(1)].F.W.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', '-P5P'],
+        ['PEPTIDE1{[Ac(1)].F.W.G.[F4COO].L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', '-P5[F4COO]'],
+        ['PEPTIDE1{[Ac(1)].F.W.G.P.L.Y.[C(1)].G.[NH2]}$$$$V2.0', '-[Tic]7Y'],
+        ['PEPTIDE1{[Ac(1)].F.W.G.P.L.T.[C(1)].G.[NH2]}$$$$V2.0', '-[Tic]7T'],
       ]
     },
     'matrix1': {
-      src: 'PEPTIDE1{[Ac(1)].F.W.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$',
+      src: 'PEPTIDE1{[Ac(1)].F.W.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0',
       params:
         {
           type: PolyToolEnumeratorTypes.Matrix,
@@ -53,25 +70,25 @@ category('PolyTool', () => {
           }
         },
       tgt: [
-        'PEPTIDE1{[Ac(1)].D.W.G.K.L.Y.[C(1)].G.[NH2]}$$$$V2.0',
-        'PEPTIDE1{[Ac(1)].D.W.G.K.L.T.[C(1)].G.[NH2]}$$$$V2.0',
-        'PEPTIDE1{[Ac(1)].D.W.G.P.L.Y.[C(1)].G.[NH2]}$$$$V2.0',
-        'PEPTIDE1{[Ac(1)].D.W.G.P.L.T.[C(1)].G.[NH2]}$$$$V2.0',
-        'PEPTIDE1{[Ac(1)].D.W.G.[F4COO].L.Y.[C(1)].G.[NH2]}$$$$V2.0',
-        'PEPTIDE1{[Ac(1)].D.W.G.[F4COO].L.T.[C(1)].G.[NH2]}$$$$V2.0',
-        'PEPTIDE1{[Ac(1)].L.W.G.K.L.Y.[C(1)].G.[NH2]}$$$$V2.0',
-        'PEPTIDE1{[Ac(1)].L.W.G.K.L.T.[C(1)].G.[NH2]}$$$$V2.0',
-        'PEPTIDE1{[Ac(1)].L.W.G.P.L.Y.[C(1)].G.[NH2]}$$$$V2.0',
-        'PEPTIDE1{[Ac(1)].L.W.G.P.L.T.[C(1)].G.[NH2]}$$$$V2.0',
-        'PEPTIDE1{[Ac(1)].L.W.G.[F4COO].L.Y.[C(1)].G.[NH2]}$$$$V2.0',
-        'PEPTIDE1{[Ac(1)].L.W.G.[F4COO].L.T.[C(1)].G.[NH2]}$$$$V2.0',
+        ["PEPTIDE1{[Ac(1)].D.W.G.K.L.Y.[C(1)].G.[NH2]}$$$$V2.0", "-F2D-P5K-[Tic]7Y"],
+        ["PEPTIDE1{[Ac(1)].D.W.G.K.L.T.[C(1)].G.[NH2]}$$$$V2.0", "-F2D-P5K-[Tic]7T"],
+        ["PEPTIDE1{[Ac(1)].D.W.G.P.L.Y.[C(1)].G.[NH2]}$$$$V2.0", "-F2D-P5P-[Tic]7Y"],
+        ["PEPTIDE1{[Ac(1)].D.W.G.P.L.T.[C(1)].G.[NH2]}$$$$V2.0", "-F2D-P5P-[Tic]7T"],
+        ["PEPTIDE1{[Ac(1)].D.W.G.[F4COO].L.Y.[C(1)].G.[NH2]}$$$$V2.0", "-F2D-P5[F4COO]-[Tic]7Y"],
+        ["PEPTIDE1{[Ac(1)].D.W.G.[F4COO].L.T.[C(1)].G.[NH2]}$$$$V2.0", "-F2D-P5[F4COO]-[Tic]7T"],
+        ["PEPTIDE1{[Ac(1)].L.W.G.K.L.Y.[C(1)].G.[NH2]}$$$$V2.0", "-F2L-P5K-[Tic]7Y"],
+        ["PEPTIDE1{[Ac(1)].L.W.G.K.L.T.[C(1)].G.[NH2]}$$$$V2.0", "-F2L-P5K-[Tic]7T"],
+        ["PEPTIDE1{[Ac(1)].L.W.G.P.L.Y.[C(1)].G.[NH2]}$$$$V2.0", "-F2L-P5P-[Tic]7Y"],
+        ["PEPTIDE1{[Ac(1)].L.W.G.P.L.T.[C(1)].G.[NH2]}$$$$V2.0", "-F2L-P5P-[Tic]7T"],
+        ["PEPTIDE1{[Ac(1)].L.W.G.[F4COO].L.Y.[C(1)].G.[NH2]}$$$$V2.0", "-F2L-P5[F4COO]-[Tic]7Y"],
+        ["PEPTIDE1{[Ac(1)].L.W.G.[F4COO].L.T.[C(1)].G.[NH2]}$$$$V2.0", "-F2L-P5[F4COO]-[Tic]7T"],
       ],
     }
   };
 
   for (const [testName, testData] of Object.entries(tests)) {
     test(`enumerator-${testName}`, async () => {
-      const res = getPtEnumeratorHelm(testData.src, testData.params);
+      const res = getPtEnumeratorHelm(testData.src, '', testData.params);
       expectArray(res, testData.tgt);
     });
   }

package/src/utils/context-menu.ts

@@ -2,11 +2,13 @@ import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 import * as ui from 'datagrok-api/ui';
 
-import {defaultErrorHandler} from './err-info';
-import {_package, addContextMenu} from '../package';
 import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {polyToolEnumerateHelmUI} from '../polytool/pt-dialog';
+
+import {defaultErrorHandler} from './err-info';
+import {polyToolEnumerateHelmUI} from '../polytool/pt-enumeration-helm-dialog';
+
+import {_package} from '../package';
 
 export type SequenceTranslatorWindowType = Window & {
   $sequenceTranslator?: {

package/src/utils/err-info.ts

@@ -6,8 +6,9 @@ import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
 
 import {_package} from '../package';
 
-export function defaultErrorHandler(err: any, shell: boolean = true): void {
+export function defaultErrorHandler(err: any, shell: boolean = true): [string, string | undefined] {
   const [errMsg, errStack] = errInfo(err);
   _package.logger.error(errMsg, undefined, errStack);
   if (shell) grok.shell.error(errMsg);
+  return [errMsg, errStack];
 }

package/src/polytool/cyclized.ts

@@ -1,56 +0,0 @@
-import {GAP_SYMBOL, INotationProvider, ISeqSplitted, SeqSplittedBase, SplitterFunc}
-  from '@datagrok-libraries/bio/src/utils/macromolecule/types';
-import {getSplitterWithSeparator, StringListSeqSplitted} from '@datagrok-libraries/bio/src/utils/macromolecule/utils';
-import {GapOriginals} from '@datagrok-libraries/bio/src/utils/seq-handler';
-import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
-
-export class CyclizedNotationProvider implements INotationProvider {
-  private readonly separatorSplitter: SplitterFunc;
-  public readonly splitter: SplitterFunc;
-
-  constructor(
-    public readonly separator: string
-  ) {
-    this.separatorSplitter = getSplitterWithSeparator(this.separator);
-    this.splitter = this._splitter.bind(this);
-  }
-
-  private _splitter(seq: string): ISeqSplitted {
-    const baseSS: ISeqSplitted = this.separatorSplitter(seq);
-    return new CyclizedSeqSplitted(baseSS.originals, GapOriginals[NOTATION.SEPARATOR]);
-  };
-}
-
-/** Gets canonical monomers for original ones with cyclization marks */
-export class CyclizedSeqSplitted extends StringListSeqSplitted {
-  private readonly seqCList: (string | null)[];
-
-  private _canonicals: string[] | null = null;
-  override get canonicals(): SeqSplittedBase {
-    if (!this._canonicals) {
-      const len = this.length;
-      this._canonicals = new Array<string>(len);
-      for (let posIdx = 0; posIdx < len; ++posIdx)
-        this._canonicals[posIdx] = this.getCanonical(posIdx);
-    }
-    return this._canonicals;
-  }
-
-  override getCanonical(posIdx: number): string {
-    if (this.isGap(posIdx)) return GAP_SYMBOL;
-
-    let cmRes: string | null = this.seqCList[posIdx];
-    if (cmRes === null) {
-      const om = this.getOriginal(posIdx);
-      cmRes = om;
-      if (om[om.length - 1] === ')')
-        cmRes = this.seqCList[posIdx] = om.replace(/\(\d+\)$/, '');
-    }
-    return cmRes;
-  }
-
-  constructor(seqOList: SeqSplittedBase, gapOriginalMonomer: string) {
-    super(seqOList, gapOriginalMonomer);
-    this.seqCList = new Array<string | null>(this.length).fill(null);
-  }
-}