@datagrok/sequence-translator 1.2.9 → 1.3.1

package/src/polytool/pt-conversion.ts

@@ -0,0 +1,307 @@
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {ALIGNMENT, ALPHABET} from '@datagrok-libraries/bio/src/utils/macromolecule';
+
+import {Rules, RuleLink, getRules} from './pt-rules';
+
+export const RULES_DIMER = '(#2)';
+export const RULES_HETERODIMER = '($2)';
+
+function addCommonTags(col: DG.Column): void {
+  col.setTag('quality', DG.SEMTYPE.MACROMOLECULE);
+  col.setTag('aligned', ALIGNMENT.SEQ);
+  col.setTag('alphabet', ALPHABET.PT);
+}
+
+export class Chain {
+  linkages: {fChain: number, sChain: number, fMonomer:number, sMonomer:number, fR:number, sR:number}[];
+  monomers: string[][];
+
+  constructor(
+    monomers: string[][],
+    linkages: {fChain: number, sChain: number, fMonomer:number, sMonomer:number, fR:number, sR:number}[]) {
+    this.linkages = linkages;
+    this.monomers = monomers;
+  }
+
+  static fromHelm(helm: string) {
+    const fragmentation = helm.split('$');
+    const rawFragments = fragmentation[0].split('|');
+    const rawLinkages = fragmentation[1].split('|');
+
+    const monomers = new Array<Array<string>>(rawFragments.length);
+    const linkages: {fChain: number, sChain: number, fMonomer:number, sMonomer:number, fR:number, sR:number}[] = [];
+
+    //HELM parsing
+    for (let i = 0; i < rawFragments.length; i++) {
+      const idxStart = rawFragments[i].indexOf('{');
+      const idxEnd = rawFragments[i].indexOf('}');
+
+      monomers[i] = rawFragments[i].slice(idxStart + 1, idxEnd).split('.');
+    }
+
+    //HELM parsing
+    for (let i = 0; i < rawLinkages.length; i++) {
+      if (rawLinkages[i] !== '' && rawLinkages[i] !== 'V2.0') {
+        const rawData = rawLinkages[i].split(',');
+        const seq1 = (rawData[0].replace('PEPTIDE', '') as unknown as number) - 1;
+        const seq2 = (rawData[1].replace('PEPTIDE', '') as unknown as number) - 1;
+        const rawDataConnctions = rawData[2].split('-');
+        const rawDataConnction1 = rawDataConnctions[0].split(':');
+        const rawDataConnction2 = rawDataConnctions[1].split(':');
+
+        linkages.push({
+          fChain: seq1,
+          sChain: seq2,
+          fMonomer: rawDataConnction1[0] as unknown as number,
+          sMonomer: rawDataConnction2[0] as unknown as number,
+          fR: rawDataConnction1[1].replace('R', '') as unknown as number,
+          sR: rawDataConnction2[1].replace('R', '') as unknown as number,
+        });
+      }
+    }
+
+    return new Chain(monomers, linkages);
+  }
+
+  static fromNotation(sequence: string, rules: Rules) {
+    const heterodimerCode = rules.heterodimerCode;
+    const homodimerCode = rules.homodimerCode;
+    const mainFragments: string[] = [];
+
+    const linkages: {fChain: number, sChain: number, fMonomer:number, sMonomer:number, fR:number, sR:number}[] = [];
+
+    //NOTICE: this works only with simple single heterodimers
+    const heterodimeric = heterodimerCode !== null? sequence.split(`(${rules.heterodimerCode!})`) : '';
+    if (heterodimerCode !== null && heterodimeric.length > 1) {
+      linkages.push({fChain: 0, sChain: 1, fMonomer: 1, sMonomer: 1, fR: 1, sR: 1});
+      mainFragments.push(heterodimeric[1].replaceAll('{', '').replaceAll('}', ''));
+      mainFragments.push(heterodimeric[2].replaceAll('{', '').replaceAll('}', ''));
+    } else {
+      mainFragments.push(sequence);
+    }
+
+    //NOTICE: this works only with simple single dimers
+    for (let i = 0; i < mainFragments.length; i++) {
+      if (homodimerCode !== null && mainFragments[i].includes(`(${homodimerCode!})`)) {
+        const idxSequence = mainFragments.length;
+
+        linkages.push({fChain: i, sChain: idxSequence, fMonomer: 1, sMonomer: 1, fR: 1, sR: 1});
+        const rawDimer = mainFragments[i].replace(`(${homodimerCode!})`, '');
+        const idx = rawDimer.indexOf('{');
+        const linker = rawDimer.slice(0, idx);
+        const body = rawDimer.replace(linker, '').replaceAll('{', '').replaceAll('}', '');
+
+        mainFragments[i] = linker + body;
+        mainFragments.push(body);
+      }
+    }
+
+    const monomers = new Array<Array<string>>(mainFragments.length);
+
+    for (let i = 0; i < mainFragments.length; i++) {
+      const rawMonomers = mainFragments[i].split('-');
+      const linkedPositions = this.getLinkedPositions(rawMonomers, rules.linkRules);
+      const [monomersCycled, allPos1, allPos2, allAttaches1, allAttaches2] =
+      this.getAllCycles(rules.linkRules, rawMonomers, linkedPositions);
+
+      const monomersReady = new Array<string>(monomersCycled.length);
+      for (let j = 0; j < monomersCycled.length; j++)
+        monomersReady[j] = `[${monomersCycled[j]}]`;
+
+      for (let j = 0; j < allPos1.length; j++) {
+        linkages.push({
+          fChain: i,
+          sChain: i,
+          fMonomer: allPos1[j],
+          sMonomer: allPos2[j],
+          fR: allAttaches1[j],
+          sR: allAttaches2[j],
+        });
+      }
+
+      monomers[i] = monomersReady;
+    }
+
+    return new Chain(monomers, linkages);
+  }
+
+  getHelmChanged(changeNumber: number, monomer: string): string {
+    //TODO: make more efficient
+    let counter = 0;
+    let idx1 = 0;
+    let idx2 = 0;
+    loop1:
+    for (let i = 0; i < this.monomers.length; i++) {
+      loop2:
+      for (let j = 0; j < this.monomers[i].length; j++) {
+        if (counter == changeNumber) {
+          idx1 = i;
+          idx2 = j;
+          break loop1;
+        }
+        counter++;
+      }
+    }
+
+    const previous = this.monomers[idx1][idx2];
+
+    this.monomers[idx1][idx2] = `[${monomer}]`;
+    const res = this.getHelm();
+    this.monomers[idx1][idx2] = previous;
+
+    return res;
+  }
+
+  getHelm(): string {
+    let helm = '';
+    for (let i = 0; i < this.monomers.length; i++) {
+      if (i > 0)
+        helm += '|';
+
+      helm += `PEPTIDE${i + 1}{`;
+
+      for (let j = 0; j < this.monomers[i].length; j++) {
+        if (j > 0)
+          helm += '.';
+        helm += this.monomers[i][j];
+      }
+      helm += `}`;
+    }
+
+    helm += '$';
+
+    for (let i = 0; i < this.linkages.length; i++) {
+      if (i > 0)
+        helm += '|';
+      helm += `PEPTIDE${this.linkages[i].fChain + 1},PEPTIDE${this.linkages[i].sChain + 1},`;
+      helm += `${this.linkages[i].fMonomer}:R${this.linkages[i].fR}-`;
+      helm += `${this.linkages[i].sMonomer}:R${this.linkages[i].sR}`;
+    }
+
+    helm += '$$$';
+    return helm;
+  }
+
+  protected static getLinkedPositions(monomers: string[], rules: RuleLink[]): [number, number][] {
+    const result: [number, number][] = new Array<[number, number]>(rules.length);
+
+    for (let i = 0; i < rules.length; i++) {
+      let firstFound = false;
+      let secondFound = false;
+      let firstIsFirst = false;
+      let firstEntryIndex = -1;
+      let secondEntryIndex = -1;
+      const add = `(${rules[i].code})`;
+      for (let j = 0; j < monomers.length; j++) {
+        if (monomers[j].includes(add)) {
+          if (firstFound) {
+            if (firstIsFirst && monomers[j] == rules[i].secondMonomer + add) {
+              secondFound = true;
+              secondEntryIndex = j;
+              break;
+            } else if (!firstIsFirst && monomers[j] == rules[i].firstMonomer + add) {
+              secondFound = true;
+              secondEntryIndex = j;
+              break;
+            } else {
+              continue;
+            }
+          } else {
+            if (monomers[j] == rules[i].firstMonomer + add) {
+              firstFound = true;
+              firstIsFirst = true;
+              firstEntryIndex = j;
+            } else if (monomers[j] == rules[i].secondMonomer + add) {
+              firstFound = true;
+              firstIsFirst = false;
+              firstEntryIndex = j;
+            } else {
+              continue;
+            }
+          }
+        }
+      }
+
+      if (!(firstFound && secondFound))
+        result[i] = [-1, -1];
+      else if (firstIsFirst)
+        result[i] = [firstEntryIndex, secondEntryIndex];
+      else
+        result[i] = [secondEntryIndex, firstEntryIndex];
+    }
+
+
+    return result;
+  }
+
+  protected static getAllCycles(rules: RuleLink[], monomers: string [], positions: [number, number][]) :
+  [string [], number [], number [], number [], number []] {
+    const allPos1: number [] = [];
+    const allPos2: number [] = [];
+    const allAttaches1: number [] = [];
+    const allAttaches2: number [] = [];
+    const ruleCount = rules.length;
+
+    for (let i = 0; i < ruleCount; i++) {
+      if (positions[i][0] == -1)
+        continue;
+
+      const firstMonomer = monomers[positions[i][0]];
+      const secondMonomer = monomers[positions[i][1]];
+
+      monomers[positions[i][0]] = monomers[positions[i][0]].replace(firstMonomer, rules[i].firstSubstitution);
+      monomers[positions[i][1]] = monomers[positions[i][1]].replace(secondMonomer, rules[i].secondSubstitution);
+
+      allPos1.push(positions[i][0] + 1);
+      allPos2.push(positions[i][1] + 1);
+      allAttaches1.push(rules[i].firstLinkingGroup);
+      allAttaches2.push(rules[i].secondLinkingGroup);
+    }
+
+    return [monomers, allPos1, allPos2, allAttaches1, allAttaches2];
+  }
+}
+
+function getHelms(sequences: string[], rules: Rules): string[] {
+  const helms = new Array<string>(sequences.length);
+  for (let i = 0; i < sequences.length; i++) {
+    const chain = Chain.fromNotation(sequences[i], rules);
+    helms[i] = chain.getHelm();
+  }
+
+  return helms;
+}
+
+export async function addTransformedColumn(
+  sequencesCol: DG.Column<string>, addHelm: boolean, ruleFiles: string[], chiralityEngine?: boolean
+): Promise<void> {
+  const df = sequencesCol.dataFrame;
+
+  const rules = await getRules(ruleFiles);
+  const targetList = getHelms(sequencesCol.toList(), rules);
+  const helmColName = df.columns.getUnusedName('transformed(' + sequencesCol.name + ')');
+  const targetHelmCol = DG.Column.fromList('string', helmColName, targetList);
+
+  addCommonTags(targetHelmCol);
+  targetHelmCol.setTag('units', NOTATION.HELM);
+
+  const molCol = await grok.functions.call('Bio:getMolFromHelm', {
+    'df': df,
+    'helmCol': targetHelmCol,
+    'chiralityEngine': chiralityEngine
+  });
+
+
+  molCol.name = df.columns.getUnusedName('molfile(' + sequencesCol.name + ')');
+  molCol.semType = DG.SEMTYPE.MOLECULE;
+
+  if (addHelm) {
+    targetHelmCol.setTag('cell.renderer', 'helm');
+    df.columns.add(targetHelmCol);
+  }
+  df.columns.add(molCol, true);
+  await grok.data.detectSemanticTypes(df);
+}

package/src/polytool/pt-dialog.ts

@@ -0,0 +1,115 @@
+/* Do not change these import lines to match external modules in webpack configuration */
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {RuleInputs, RULES_PATH, RULES_STORAGE_NAME} from './pt-rules';
+import {addTransformedColumn} from './pt-conversion';
+
+import {handleError} from './utils';
+import {getLibrariesList, HelmInput, getEnumeration} from './pt-enumeration';
+
+const PT_ERROR_DATAFRAME = 'No dataframe with macromolecule columns open';
+const PT_WARNING_COLUMN = 'No marcomolecule column chosen!';
+
+const PT_UI_GET_HELM = 'Get HELM';
+const PT_UI_ADD_HELM = 'Add HELM column';
+const PT_UI_USE_CHIRALITY = 'Chirality engine';
+const PT_UI_DIALOG_CONVERSION = 'Poly Tool Conversion';
+const PT_UI_DIALOG_ENUMERATION = 'Poly Tool Enumeration';
+const PT_UI_RULES_USED = 'Rules used';
+
+export async function getPolyToolConversionDialog(): Promise<DG.Dialog> {
+  const targetColumns = grok.shell.t.columns.bySemTypeAll(DG.SEMTYPE.MACROMOLECULE);
+  if (!targetColumns)
+    throw new Error(PT_ERROR_DATAFRAME);
+
+  const targetColumnInput = ui.columnInput(
+    'Column', grok.shell.t, targetColumns[0], null,
+    {filter: (col: DG.Column) => col.semType === DG.SEMTYPE.MACROMOLECULE}
+  );
+
+  const generateHelmChoiceInput = ui.boolInput(PT_UI_GET_HELM, true);
+  ui.tooltip.bind(generateHelmChoiceInput.root, PT_UI_ADD_HELM);
+
+  const chiralityEngineInput = ui.boolInput(PT_UI_USE_CHIRALITY, false);
+  const ruleInputs = new RuleInputs(RULES_PATH, RULES_STORAGE_NAME, '.json');
+  const rulesHeader = ui.inlineText([PT_UI_RULES_USED]);
+  ui.tooltip.bind(rulesHeader, 'Add or specify rules to use');
+  const rulesForm = await ruleInputs.getForm();
+
+  const div = ui.div([
+    targetColumnInput,
+    generateHelmChoiceInput,
+    chiralityEngineInput,
+    rulesHeader,
+    rulesForm
+  ]);
+
+  const dialog = ui.dialog(PT_UI_DIALOG_CONVERSION)
+    .add(div)
+    .onOK(async () => {
+      const pi = DG.TaskBarProgressIndicator.create('PolyTool converting');
+      try {
+        const sequencesCol = targetColumnInput.value;
+        if (!sequencesCol) {
+          grok.shell.warning(PT_WARNING_COLUMN);
+          return;
+        }
+
+        const files = await ruleInputs.getActive();
+
+        addTransformedColumn(sequencesCol!,
+          generateHelmChoiceInput.value!,
+          files,
+          chiralityEngineInput.value!);
+      } catch (err: any) {
+        handleError(err);
+      } finally {
+        pi.close();
+      }
+    });
+
+  return dialog;
+}
+
+export async function getPolyToolEnumerationDialog(): Promise<DG.Dialog> {
+  const helmInput = await HelmInput.init();
+
+  const libList = await getLibrariesList();
+  const screenLibrary = ui.choiceInput('Library to use', null, libList);
+
+  screenLibrary.input.setAttribute('style', `min-width:250px!important;`);
+
+  const div = ui.div([
+    helmInput.getDiv(),
+    screenLibrary.root
+  ]);
+
+  const dialog = ui.dialog(PT_UI_DIALOG_ENUMERATION)
+    .add(div)
+    .onOK(async () => {
+      try {
+        const helmString = helmInput.getHelmString();
+        const helmSelections = helmInput.getHelmSelections();
+        if (helmString === undefined || helmString === '') {
+          grok.shell.warning('PolyTool: no molecule was provided');
+        } else if (helmSelections === undefined || helmSelections.length < 1) {
+          grok.shell.warning('PolyTool: no selection was provided');
+        } else {
+          const molecules = await getEnumeration(helmString, helmSelections, screenLibrary.value!);
+          const molCol = DG.Column.fromStrings('Enumerated', molecules);
+          const df = DG.DataFrame.fromColumns([molCol]);
+          grok.shell.addTableView(df);
+        }
+      } catch (err: any) {
+
+      } finally {
+
+      }
+    }).onCancel(() => {
+
+    });
+
+  return dialog;
+}

package/src/polytool/pt-enumeration.ts

@@ -0,0 +1,127 @@
+import * as ui from 'datagrok-api/ui';
+import * as grok from 'datagrok-api/grok';
+
+import {IHelmHelper, getHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
+import {IHelmWebEditor} from '@datagrok-libraries/bio/src/helm/types';
+import '@datagrok-libraries/bio/src/types/helm';
+import '@datagrok-libraries/bio/src/types/jsdraw2';
+import * as org from 'org';
+import $ from 'cash-dom';
+import {Unsubscribable, fromEvent} from 'rxjs';
+import {IMonomerLibFileManager, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+
+import {Chain} from './pt-conversion';
+
+const LIB_PATH = 'System:AppData/Bio/monomer-libraries/';
+const PT_HELM_EXAMPLE = 'PEPTIDE1{[R].[F].[T].[G].[H].[F].[G].[A].[A].[Y].[P].[E].[NH2]}$$$$';
+
+export async function getLibrariesList(): Promise<string[]> {
+  const monomerLibHelper: IMonomerLibHelper = await grok.functions.call('Bio:getMonomerLibHelper', {});
+  const monomerFileManager: IMonomerLibFileManager = await monomerLibHelper.getFileManager();
+  return monomerFileManager.getValidLibraryPaths();
+}
+
+export async function getEnumeration(helmString: string, helmSelections: number[], screenLibrary: string):
+  Promise<string[]> {
+  const variableMonomers = await getAvaialableMonomers(screenLibrary);
+  const chain: Chain = Chain.fromHelm(helmString);
+  const size = helmSelections.length*variableMonomers.length;
+  const enumerations = new Array<string>(size);
+
+  for (let i = 0; i < helmSelections.length; i++) {
+    for (let j = 0; j < variableMonomers.length; j++)
+      enumerations[i*variableMonomers.length + j] = chain.getHelmChanged(helmSelections[i], variableMonomers[j]);
+  }
+
+  return enumerations;
+}
+
+export class HelmInput {
+  webEditorHost: HTMLDivElement | null;
+  webEditorApp: org.helm.IWebEditorApp | null;
+  helmHelper: IHelmHelper;
+  editor: IHelmWebEditor;
+  subs: Unsubscribable[];
+
+  helmString: string = PT_HELM_EXAMPLE;
+  helmSelection: number[];
+
+  constructor(
+    helmHelper: IHelmHelper, editor: IHelmWebEditor) {
+    this.helmHelper = helmHelper;
+    this.editor = editor;
+
+    this.webEditorHost = null;
+    this.webEditorApp = null;
+    const subs: Unsubscribable[] = [];
+
+    subs.push(fromEvent<MouseEvent>(editor.host, 'click').subscribe(() => {
+      this.webEditorHost = ui.div();
+      //TODO: use not hh, but anything from editor.getHelm(true)
+      this.webEditorApp = helmHelper.createWebEditorApp(this.webEditorHost, this.getHelmString());
+      const dlg = ui.dialog({showHeader: false, showFooter: true})
+        .add(this.webEditorHost!)
+        .onOK(() => {
+          try {
+            const webEditorValue = this.webEditorApp!.canvas.getHelm(true)
+              .replace(/<\/span>/g, '').replace(/<span style='background:#bbf;'>/g, '');
+            editor.editor.setHelm(webEditorValue);
+            this.helmString = webEditorValue;
+            this.helmSelection = [];
+
+            //@ts-ignore
+            const selection = this.webEditorApp?.canvas.helm.jsd.m.atoms;
+            for (let i = 0; i < selection.length; i++) {
+              if (selection[i].selected)
+                this.helmSelection.push(i);
+            }
+          } catch (err: any) {
+            //this.logger.error(err);
+          } finally {
+            $(this.webEditorHost).empty();
+            this.webEditorHost = null;
+            this.webEditorApp = null;
+          }
+        })
+        .onCancel(() => {
+          $(this.webEditorHost).empty();
+          this.webEditorHost = null;
+          this.webEditorApp = null;
+        })
+        .show({modal: true, fullScreen: true});
+    }));
+  }
+
+  static async init() {
+    const helmHelper = await getHelmHelper();
+
+    const editor = helmHelper.createHelmWebEditor();
+    editor.host.style.width = '200px';
+    editor.host.style.height = '100px';
+    editor.host.style.paddingLeft = '40px';
+    editor.editor.setHelm(PT_HELM_EXAMPLE);
+
+    return new HelmInput(helmHelper, editor);
+  }
+
+  getHelmString(): string {
+    return this.helmString;
+  }
+
+  getHelmSelections() {
+    return this.helmSelection;
+  }
+
+  getDiv(): HTMLDivElement {
+    const title = ui.divText('Macromolecule', {style: {paddingTop: '43px', color: 'var(--grey-4)'}});
+
+    return ui.divH([title, this.editor.host], {style: {paddingLeft: '48px'}});
+  }
+}
+
+async function getAvaialableMonomers(screenLibrary: string): Promise<string[]> {
+  const monomerLibHelper: IMonomerLibHelper = await grok.functions.call('Bio:getMonomerLibHelper', {});
+  const monomerLib = await monomerLibHelper.readLibrary(LIB_PATH, screenLibrary);
+  //NOTICE: works with Peptides only
+  return monomerLib.getMonomerSymbolsByType('PEPTIDE');
+}

package/src/polytool/pt-rules.ts

@@ -0,0 +1,73 @@
+import * as DG from 'datagrok-api/dg';
+import * as grok from 'datagrok-api/grok';
+import {ActiveFiles} from '@datagrok-libraries/utils/src/settings/active-files-base';
+
+export const RULES_PATH = 'System:AppData/SequenceTranslator/polytool-rules/';
+export const RULES_STORAGE_NAME = 'Polytool';
+export const RULES_TYPE_LINK = 'link';
+export const RULES_TYPE_HOMODIMER = 'fragmentDuplication';
+export const RULES_TYPE_HETERODIMER = 'differentFragments';
+
+export class RuleInputs extends ActiveFiles {
+  constructor(path: string, userStorageName: string, ext: string ) {
+    super(path, userStorageName, ext);
+  }
+}
+
+export type Rules = {
+  homodimerCode: string | null,
+  heterodimerCode: string | null,
+  linkRules: RuleLink[]
+}
+
+export type RuleLink = {
+  code: number,
+  firstMonomer: string,
+  secondMonomer: string,
+  firstSubstitution: string,
+  secondSubstitution: string,
+  firstLinkingGroup: number,
+  secondLinkingGroup: number
+}
+
+export async function getRules(ruleFiles: string[]): Promise<Rules> {
+  const fileSource = new DG.FileSource(RULES_PATH);
+  const linkRules: RuleLink[] = [];
+  const rules: Rules = {homodimerCode: null, heterodimerCode: null, linkRules: linkRules};
+
+  for (let i = 0; i < ruleFiles.length; i++) {
+    const rulesRaw = await fileSource.readAsText(ruleFiles[i].replace(RULES_PATH, ''));
+    const ruleSingle = JSON.parse(rulesRaw);
+    for (let j = 0; j < ruleSingle.length; j++) {
+      if (ruleSingle[j].type !== undefined && ruleSingle[j].code !== undefined) {
+        switch (ruleSingle[j].type) {
+        case RULES_TYPE_LINK: {
+          const rule = ruleSingle[j].monomericSubstitution;
+          rule['code'] = ruleSingle[j].code;
+          linkRules.push(rule);
+          break;
+        }
+        case RULES_TYPE_HOMODIMER: {
+          if (rules.homodimerCode)
+            grok.shell.warning(`PolyTool: homodimer code is duplicated in rules.`);
+          rules.homodimerCode = ruleSingle[j].code;
+          break;
+        }
+        case RULES_TYPE_HETERODIMER: {
+          if (rules.heterodimerCode)
+            grok.shell.warning(`PolyTool: heterodimer code is duplicated in rules.`);
+          rules.heterodimerCode = ruleSingle[j].code;
+          break;
+        }
+        default:
+          grok.shell.warning(`PolyTool: Unexpected type - '${ruleSingle[j]}'.`);
+          break;
+        }
+      } else {
+        grok.shell.warning('Polytool: rules contain invalid rule');
+      }
+    }
+  }
+
+  return rules;
+}

package/src/polytool/utils.ts

@@ -2,6 +2,7 @@
 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 {ALPHABET, ALIGNMENT, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
@@ -18,3 +19,9 @@ function addCommonTags(col: DG.Column<any>) {
   col.setTag('alphabet', ALPHABET.PT);
 }
 
+export function handleError(err: any): void {
+  const errMsg: string = err instanceof Error ? err.message : err.toString();
+  const stack: string | undefined = err instanceof Error ? err.stack : undefined;
+  grok.shell.error(errMsg);
+  _package.logger.error(err.message, undefined, stack);
+}

package/src/tests/helm-to-nucleotides.ts

@@ -1,8 +1,3 @@
-/* Do not change these import lines to match external modules in webpack configuration */
-import * as grok from 'datagrok-api/grok';
-import * as ui from 'datagrok-api/ui';
-import * as DG from 'datagrok-api/dg';
-
 import {before, category, expect, test} from '@datagrok-libraries/utils/src/test';
 import {getNucleotidesSequence} from '../apps/translator/model/conversion-utils';
 import {loadJsonData} from '../apps/common/model/data-loader/json-loader';

package/tsconfig.json

@@ -65,7 +65,7 @@
     // "emitDecoratorMetadata": true,               /* Enables experimental support for emitting type metadata for decorators. */
 
     /* Advanced Options */
-    "skipLibCheck": false,                          /* Skip type checking of declaration files. */
+    "skipLibCheck": true,                           /* Skip type checking of declaration files. */
     "forceConsistentCasingInFileNames": true        /* Disallow inconsistently-cased references to the same file. */
   }
 }