@datagrok/sequence-translator 1.3.11 → 1.3.12

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

@@ -0,0 +1,127 @@
+import * as ui from 'datagrok-api/ui';
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+
+import {PolyToolPlaceholders} from './types';
+
+export class PolyToolPlaceholdersInput extends DG.JsInputBase<DG.DataFrame> {
+  get inputType(): string { return 'Positions'; }
+
+  get dataType(): string { return DG.TYPE.DATA_FRAME; }
+
+  getInput(): HTMLElement { return this.gridHost; }
+
+  getValue(): DG.DataFrame {
+    return this.grid.dataFrame;
+  }
+
+  setValue(value: DG.DataFrame): void {
+    this.grid.dataFrame = value;
+  }
+
+  getStringValue(): string {
+    return this.grid.dataFrame.toCsv();
+  }
+
+  setStringValue(str: string): void {
+    this.grid.dataFrame = DG.DataFrame.fromCsv(str);
+  }
+
+  get placeholdersValue() {
+    return dfToPlaceholders(this.grid.dataFrame);
+  }
+
+  private readonly gridHost: HTMLDivElement;
+  public readonly grid: DG.Grid;
+
+  protected constructor(name: string | undefined, grid: DG.Grid, heightRowCount?: number) {
+    super();
+
+    if (name) this.captionLabel.innerText = name;
+
+    this.gridHost = ui.div([], {
+      classes: 'ui-input-editor',
+      style: {width: '100%', height: '100%', marginTop: '-8px'},
+    });
+
+    this.grid = grid;
+    this.gridHost.append(this.grid.root);
+
+    if (heightRowCount != null) {
+      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.grid.root.style.width = `100%`;
+
+    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);
+  }
+
+  public static async create(
+    name?: string, value?: DG.DataFrame, options?: {}, heightRowCount?: number
+  ): Promise<PolyToolPlaceholdersInput> {
+    const df: DG.DataFrame = value ?? DG.DataFrame.create(0);
+    const grid = (await df.plot.fromType(DG.VIEWER.GRID, options)) as DG.Grid;
+    return new PolyToolPlaceholdersInput(name, grid, heightRowCount);
+  }
+
+  // -- Update view --
+
+  private updateGridHeight(visibleRowCount: number): void {
+    const gridHeight = this.grid.colHeaderHeight + visibleRowCount * this.grid.props.rowHeight + 6 + 2;
+    this.grid.root.style.height = `${gridHeight}px`;
+  }
+
+  // -- Handle events --
+
+  private rootOnSizeChanged(): void {
+
+  }
+}
+
+export function getPlaceholdersFromText(src: string): PolyToolPlaceholders {
+  const res: PolyToolPlaceholders = {};
+  for (const line of src.split('\n')) {
+    const lineM = /^\s*(?<pos>\d+)\s*:\s*(?<monomers>.+)$/.exec(line);
+    if (lineM) {
+      const pos: number = parseInt(lineM.groups!['pos']) - 1;
+      const monomerList: string[] = lineM.groups!['monomers'].split(',').map(m => m.trim());
+      if (!(pos in res)) res[pos] = [];
+      res[pos].push(...monomerList);
+    }
+  }
+  return res;
+}
+
+export function dfToPlaceholders(df: DG.DataFrame): PolyToolPlaceholders {
+  const res: PolyToolPlaceholders = {};
+  for (let rowI = 0; rowI < df.rowCount; rowI++) {
+    const pos = parseInt(df.get('Position', rowI));
+    if (!isNaN(pos)) {
+      const monomerSymbolList = parseMonomerSymbolList(df.get('Monomers', rowI));
+      if (monomerSymbolList.length > 0)
+        res[pos - 1] = monomerSymbolList;
+    }
+  }
+  return res;
+}
+
+export function parseMonomerSymbolList(src: string): string[] {
+  // L, L-hArg(Et,Et), "hArg(Et,Et)"
+  return src.split(/,(?![^(]*\))/)
+    .map((s) => {
+      s = s.trim();
+      if (s.slice(0, 1) === `"` && s.slice(-1) === `"`) s = s.slice(1, -1);
+      if (s.slice(0, 1) === `'` && s.slice(-1) === `'`) s = s.slice(1, -1);
+      return s.trim();
+    })
+    .filter((s) => !!s);
+}

package/src/polytool/types.ts

@@ -0,0 +1,18 @@
+import * as ui from 'datagrok-api/ui';
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+
+export enum PolyToolEnumeratorTypes {
+  Single = 'single',
+  Matrix = 'matrix',
+}
+
+export type PolyToolEnumeratorType = typeof PolyToolEnumeratorTypes[keyof typeof PolyToolEnumeratorTypes];
+
+export type PolyToolPlaceholders = { [position: number]: string[] };
+
+export type PolyToolEnumeratorParams = {
+  type: PolyToolEnumeratorType;
+  /** position key is zero-based */
+  placeholders: PolyToolPlaceholders;
+}

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

@@ -0,0 +1,78 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {before, after, category, expect, test, expectArray} from '@datagrok-libraries/utils/src/test';
+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;
+
+  before(async () => {
+    helmHelper = await getHelmHelper(); // initialize JSDraw2 and org
+  });
+
+  after(async () => {
+
+  });
+
+  const tests: {
+    [testName: string]: { src: string, params: PolyToolEnumeratorParams, tgt: string[] }
+  } = {
+    'single1': {
+      src: 'PEPTIDE1{[Ac(1)].F.W.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$',
+      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',
+        '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',
+      ]
+    },
+    'matrix1': {
+      src: 'PEPTIDE1{[Ac(1)].F.W.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$',
+      params:
+        {
+          type: PolyToolEnumeratorTypes.Matrix,
+          placeholders: {
+            [1]: ['D', 'L'],
+            [4]: ['K', 'P', 'F4COO'],
+            [6]: ['Y', 'T'],
+          }
+        },
+      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',
+      ],
+    }
+  };
+
+  for (const [testName, testData] of Object.entries(tests)) {
+    test(`enumerator-${testName}`, async () => {
+      const res = getPtEnumeratorHelm(testData.src, testData.params);
+      expectArray(res, testData.tgt);
+    });
+  }
+});

package/src/utils/err-info.ts

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

package/webpack.config.js

@@ -17,16 +17,9 @@ module.exports = {
   },
   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'], exclude: [/node_modules/]},
+      {test: /\.ts(x?)$/, use: 'ts-loader', exclude: [/node_modules/]},
+      {test: /\.css$/, use: ['style-loader', 'css-loader'], exclude: [/node_modules/]},
     ],
   },
   devtool: 'source-map',