@datagrok/sequence-translator 1.3.0 → 1.3.2

package/src/apps/translator/view/ui.ts

@@ -3,13 +3,12 @@ import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 
+import {Subject, BehaviorSubject, Observable} from 'rxjs';
+
 import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
-import * as rxjs from 'rxjs';
-
 import {DEFAULT_FORMATS} from '../../common/model/const';
-import {CODES_TO_HELM_DICT} from '../../common/model/data-loader/json-loader';
 import {download} from '../../common/model/helpers';
 import {FormatDetector} from '../../common/model/parsing-validation/format-detector';
 import {SequenceValidator} from '../../common/model/parsing-validation/sequence-validator';
@@ -22,19 +21,25 @@ import {MonomerLibViewer} from '../../common/view/monomer-lib-viewer';
 import {SequenceToMolfileConverter} from '../../structure/model/sequence-to-molfile';
 import {convert, getSupportedTargetFormats, getTranslatedSequences} from '../model/conversion-utils';
 import {FormatConverter} from '../model/format-converter';
+import {ITranslationHelper} from '../../../types';
+
 import {NUCLEOTIDES_FORMAT, SEQUENCE_COPIED_MSG, SEQ_TOOLTIP_MSG} from './const';
 import './style.css';
+import {_package} from '../../../package';
 
 const enum REQUIRED_COLUMN_LABEL {
   SEQUENCE = 'Sequence',
 }
+
 const REQUIRED_COLUMN_LABELS = [REQUIRED_COLUMN_LABEL.SEQUENCE];
 
 class TranslatorAppLayout {
   private eventBus: EventBus;
-  private inputFormats = Object.keys(CODES_TO_HELM_DICT).concat(DEFAULT_FORMATS.HELM);
+  private inputFormats = Object.keys(_package.jsonData.codesToHelmDict).concat(DEFAULT_FORMATS.HELM);
 
-  constructor() {
+  constructor(
+    private readonly th: ITranslationHelper
+  ) {
     this.moleculeImgDiv = ui.div([]);
     this.moleculeImgDiv.className = 'mol-host';
     this.moleculeImgDiv.style.border = '1px solid var(--grey-2)';
@@ -63,7 +68,7 @@ class TranslatorAppLayout {
   }
 
   // todo: reduce # of state vars by further refactoring legacy code
-  private onInput = new rxjs.Subject<string>();
+  private onInput = new Subject<string>();
   private moleculeImgDiv: HTMLDivElement;
   private outputTableDiv: HTMLDivElement;
   private formatChoiceInput: DG.InputBase;
@@ -105,7 +110,7 @@ class TranslatorAppLayout {
     const outputFormats = ui.choiceInput(
       'Output format',
       NUCLEOTIDES_FORMAT,
-      getSupportedTargetFormats(),
+      getSupportedTargetFormats(this.th),
       (value: string) => this.eventBus.selectOutputFormat(value)
     );
     const convertBulkButton = this.createConvertBulkButton();
@@ -156,7 +161,7 @@ class TranslatorAppLayout {
       DG.TYPE.STRING,
       newColumnName,
       sequenceColumn.toList().map((sequence: string) => {
-        const result = convert(sequence, inputFormat, outputFormat);
+        const result = convert(sequence, inputFormat, outputFormat, this.th);
         return result;
       })
     );
@@ -180,7 +185,8 @@ class TranslatorAppLayout {
   }
 
   private constructSingleSequenceControls(): HTMLDivElement {
-    const sequenceColoredInput = new ColoredTextInput(this.sequenceInputBase, highlightInvalidSubsequence);
+    const sequenceColoredInput = new ColoredTextInput(this.sequenceInputBase,
+      (s: string) => { return highlightInvalidSubsequence(s, this.th); });
 
     const downloadMolfileButton = ui.button(
       'Get SDF',
@@ -242,8 +248,9 @@ class TranslatorAppLayout {
     this.outputTableDiv.innerHTML = '';
     // todo: does not detect correctly (U-A)(U-A)
     const indexOfInvalidChar = (!this.format) ? 0 :
-      (new SequenceValidator(this.sequence)).getInvalidCodeIndex(this.format!);
-    const translatedSequences = getTranslatedSequences(this.sequence, indexOfInvalidChar, this.format!);
+      this.th.createSequenceValidator(this.sequence).getInvalidCodeIndex(this.format!);
+    const translatedSequences = getTranslatedSequences(
+      this.sequence, indexOfInvalidChar, this.format!, this.th);
     const tableRows = [];
 
     for (const key of Object.keys(translatedSequences)) {
@@ -278,7 +285,7 @@ class TranslatorAppLayout {
   private init(): void {
     this.sequence = this.getFormattedSequence();
 
-    this.format = (new FormatDetector(this.sequence)).getFormat();
+    this.format = this.th.createFormatDetector(this.sequence).getFormat();
 
     // warning: getMolfile relies on 'this.format', so the order is important
     this.molfile = this.getMolfile();
@@ -292,7 +299,8 @@ class TranslatorAppLayout {
     if (!this.format)
       return '';
     if (this.format === DEFAULT_FORMATS.HELM) {
-      const axolabs = (new FormatConverter(this.sequence, this.format).convertTo(DEFAULT_FORMATS.AXOLABS));
+      const axolabs = this.th.createFormatConverter(this.sequence, this.format)
+        .convertTo(DEFAULT_FORMATS.AXOLABS);
       return (new SequenceToMolfileConverter(axolabs, false, DEFAULT_FORMATS.AXOLABS).convert());
     }
     const molfile = (new SequenceToMolfileConverter(this.sequence, false, this.format)).convert();
@@ -473,13 +481,13 @@ class ColumnInputsManager {
 export class EventBus {
   private static _instance: EventBus;
 
-  private _tableSelection$ = new rxjs.BehaviorSubject<DG.DataFrame | null>(null);
+  private _tableSelection$ = new BehaviorSubject<DG.DataFrame | null>(null);
   private _columnSelection = Object.fromEntries(REQUIRED_COLUMN_LABELS.map((columnLabel: string) => {
-    const columnSelection$ = new rxjs.BehaviorSubject<DG.Column<string> | null>(null);
+    const columnSelection$ = new BehaviorSubject<DG.Column<string> | null>(null);
     return [columnLabel, columnSelection$];
   }));
-  private _inputFormatSelection$ = new rxjs.BehaviorSubject<string>(DEFAULT_FORMATS.AXOLABS);
-  private _outputFormatSelection$ = new rxjs.BehaviorSubject<string>(NUCLEOTIDES_FORMAT);
+  private _inputFormatSelection$ = new BehaviorSubject<string>(DEFAULT_FORMATS.AXOLABS);
+  private _outputFormatSelection$ = new BehaviorSubject<string>(NUCLEOTIDES_FORMAT);
 
   private constructor() {}
 
@@ -489,7 +497,7 @@ export class EventBus {
     return EventBus._instance;
   }
 
-  get tableSelected$(): rxjs.Observable<DG.DataFrame | null> {
+  get tableSelected$(): Observable<DG.DataFrame | null> {
     return this._tableSelection$.asObservable();
   }
 
@@ -528,11 +536,15 @@ export class EventBus {
 
 export class OligoTranslatorUI extends IsolatedAppUIBase {
   private readonly topPanel: HTMLElement[];
-  private readonly layout = new TranslatorAppLayout();
+  private readonly layout: TranslatorAppLayout;
 
-  constructor() {
+  constructor(
+    private readonly th: ITranslationHelper
+  ) {
     super(APP_NAME.TRANSLATOR);
 
+    this.th = _package;
+    this.layout = new TranslatorAppLayout(this.th);
     const viewMonomerLibIcon = ui.iconFA('book', MonomerLibViewer.view, 'View monomer library');
     this.topPanel = [
       viewMonomerLibIcon,

package/src/demo/demo-st-ui.ts

@@ -3,8 +3,7 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {delay} from '@datagrok-libraries/utils/src/test';
-import {loadJsonData} from '../apps/common/model/data-loader/json-loader';
-import {_package, oligoTranslatorApp, oligoPatternApp, oligoStructureApp} from '../package';
+import {oligoTranslatorApp, oligoPatternApp, oligoStructureApp} from '../package';
 import {tryCatch} from '../apps/common/model/helpers';
 
 export async function demoOligoTranslatorUI() {
@@ -31,6 +30,7 @@ export async function demoOligoStructureUI() {
       const event = new Event('input');
       textarea.dispatchEvent(event);
     }
+
     const view = await oligoStructureApp();
     grok.shell.addView(view);
     const inputSequences = ['Afcgacsu', 'Afcgacsu', 'Afcgacsu'];

package/src/package-test.ts

@@ -1,10 +1,17 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
+
 import {runTests, tests, TestContext} from '@datagrok-libraries/utils/src/test';
+
 import './tests/formats-to-helm';
 import './tests/helm-to-nucleotides';
 import './tests/formats-support';
+import './tests/files-tests';
+
+import {OligoToolkitTestPackage} from './tests/utils';
 
-export const _package = new DG.Package();
+export const _package = new OligoToolkitTestPackage();
 export {tests};
 
 //name: test
@@ -13,6 +20,6 @@ export {tests};
 //input: object testContext {optional: true}
 //output: dataframe result
 export async function test(category: string, test: string, testContext: TestContext): Promise<DG.DataFrame> {
-  const data = await runTests({category, test, testContext});
+  const data = await runTests({category, test, testContext, verbose: true});
   return DG.DataFrame.fromObjects(data)!;
 }

package/src/package.ts

@@ -1,7 +1,6 @@
 import DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
 
-import {loadJsonData} from './apps/common/model/data-loader/json-loader';
 import {MonomerLibWrapper} from './apps/common/model/monomer-lib/lib-wrapper';
 import {OligoToolkitPackage} from './apps/common/model/oligo-toolkit-package';
 import {FormatDetector} from './apps/common/model/parsing-validation/format-detector';
@@ -19,7 +18,7 @@ import {getExternalAppViewFactories} from './plugins/mermade';
 import {getPolyToolConversionDialog, getPolyToolEnumerationDialog} from './polytool/pt-dialog';
 import {_setPeptideColumn} from './polytool/utils';
 import {PolyToolCsvLibHandler} from './polytool/csv-to-json-monomer-lib-converter';
-
+import {ITranslationHelper} from './types';
 
 export const _package: OligoToolkitPackage = new OligoToolkitPackage();
 
@@ -29,11 +28,11 @@ export const _package: OligoToolkitPackage = new OligoToolkitPackage();
 //tags: app
 //output: view v
 export async function oligoToolkitApp(): Promise<DG.ViewBase> {
-  await initSequenceTranslatorLibData();
-  const externalViewFactories = await getExternalAppViewFactories();
+  await _package.initLibData();
+  const externalViewFactories = await getExternalAppViewFactories(_package);
   if (!externalViewFactories)
     throw new Error('External app view factories not loaded');
-  const appUI = new CombinedAppUI(externalViewFactories!);
+  const appUI = new CombinedAppUI(externalViewFactories!, _package);
   const view = await appUI.getAppView();
   return view;
 }
@@ -68,16 +67,18 @@ export async function oligoStructureApp(): Promise<DG.ViewBase> {
   return view;
 }
 
-//name: initSequenceTranslatorLibData
-export async function initSequenceTranslatorLibData(): Promise<void> {
-  await loadJsonData();
-  await _package.initMonomerLib();
+//name: getTranslationHelper
+//output: object result
+export async function getTranslationHelper(): Promise<ITranslationHelper> {
+  await _package.initLibData();
+  return _package;
 }
 
 //name: getCodeToWeightsMap
 //output: object result
-export function getCodeToWeightsMap(): {[key: string]: number} {
-  const map = MonomerLibWrapper.getInstance().getCodesToWeightsMap();
+export function getCodeToWeightsMap(): { [key: string]: number } {
+  const monomerLibWrapper = _package.monomerLibWrapper;
+  const map = monomerLibWrapper.getCodesToWeightsMap();
   return Object.fromEntries(map);
 }
 
@@ -85,8 +86,8 @@ export function getCodeToWeightsMap(): {[key: string]: number} {
 //input: string sequence
 //output: bool result
 export function validateSequence(sequence: string): boolean {
-  const validator = new SequenceValidator(sequence);
-  const format = (new FormatDetector(sequence).getFormat());
+  const validator = _package.createSequenceValidator(sequence);
+  const format = _package.createFormatDetector(sequence).getFormat();
   return (format === null) ? false : validator.isValidSequence(format!);
 }
 
@@ -137,13 +138,13 @@ export async function demoOligoStructure(): Promise<void> {
 export async function translateOligonucleotideSequence(
   sequence: string, sourceFormat: string, targetFormat: string
 ): Promise<string> {
-  await initSequenceTranslatorLibData();
-  return (new FormatConverter(sequence, sourceFormat)).convertTo(targetFormat);
+  await _package.initLibData();
+  return _package.createFormatConverter(sequence, sourceFormat).convertTo(targetFormat);
 }
 
 async function getSpecifiedAppView(appName: string): Promise<DG.ViewBase> {
-  await initSequenceTranslatorLibData();
-  const appUI = getSpecifiedAppUI(appName);
+  await _package.initLibData();
+  const appUI = getSpecifiedAppUI(appName, _package);
   const view = await appUI.getAppView();
   return view;
 }

package/src/plugins/mermade.ts

@@ -5,19 +5,22 @@ import * as DG from 'datagrok-api/dg';
 
 import {ExternalPluginUI} from '../apps/common/view/utils';
 import {ColoredTextInput} from '../apps/common/view/components/colored-input/colored-text-input';
-import {highlightInvalidSubsequence} from '../apps/common/view/components/colored-input/input-painters';
-import {CODES_TO_SYMBOLS_DICT} from '../apps/common/model/data-loader/json-loader';
 import {MERMADE} from './const';
+import {ITranslationHelper} from '../types';
 
-export async function getExternalAppViewFactories(): Promise<{[name: string]: () => DG.View} | undefined> {
+import {_package} from '../package';
+
+export async function getExternalAppViewFactories(
+  th: ITranslationHelper
+): Promise<{ [name: string]: () => DG.View } | undefined> {
   const externalPluginData = {
     [MERMADE.FUNCTION_NAME]: {
       tabName: MERMADE.TAB_NAME,
-      parameters: getMerMadeParameters()
+      parameters: getMerMadeParameters(th)
     },
   };
 
-  const result: {[tabName: string]: () => DG.View} = {};
+  const result: { [tabName: string]: () => DG.View } = {};
 
   for (const [pluginName, data] of Object.entries(externalPluginData)) {
     let div: HTMLDivElement;
@@ -37,12 +40,12 @@ export async function getExternalAppViewFactories(): Promise<{[name: string]: ()
   return result;
 }
 
-function getMerMadeParameters(): {[name: string]: any} {
+function getMerMadeParameters(th: ITranslationHelper): { [name: string]: any } {
   const base = ui.textInput('', '');
-  const input = new ColoredTextInput(base, highlightInvalidSubsequence);
+  const input = new ColoredTextInput(base, th.highlightInvalidSubsequence);
 
   return {
     coloredInput: input,
-    codes: CODES_TO_SYMBOLS_DICT
+    codes: th.jsonData.codesToSymbolsDict
   };
 }

package/src/polytool/pt-rules.ts

@@ -2,7 +2,7 @@ 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/Bio/polytool-rules/';
+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';

package/src/tests/const.ts

@@ -1,6 +1,7 @@
-type Dict = {[key: string]: string};
+type Dict = { [key: string]: string };
 
-export const formatsToHelm: {[key: string]: Dict} = {
+/* eslint-disable max-len*/
+export const formatsToHelm: { [key: string]: Dict } = {
   'Axolabs': {
     'UfAfsCfsGfuacg': 'RNA1{[fR](U)p.[fR](A)[sp].[fR](C)[sp].[fR](G)p.[25r](U)p.[25r](A)p.[25r](C)p.[25r](G)}$$$$'
   },
@@ -15,10 +16,11 @@ export const formatsToHelm: {[key: string]: Dict} = {
 export const helmToNucleotides: Dict = {
   'RNA1{[fR](U)p.[fR](A)[sp].[fR](C)[sp].[fR](G)p.[25r](U)p.[25r](A)p.[25r](C)p.[25r](G)}$$$$': 'UACGUACG',
 
-  'RNA1{r(A)[sp].r(G)p.r(C)[sp].[fR](U)p.[fR](A)p.[fR](C)p.[fR](G)p.[25r](U)p.[25r](A)p.[25r](C)p.[25r](G)p.d([m5C])}$$$$': 'AGCUACGUACGC',
+  // TODO: Handle monomer .d([m5C])
+  'RNA1{r(A)[sp].r(G)p.r(C)[sp].[fR](U)p.[fR](A)p.[fR](C)p.[fR](G)p.[25r](U)p.[25r](A)p.[25r](C)p.[25r](G)p}$$$$': 'AGCUACGUACG',
 
   'RNA1{[25r](U)[sp].[25r](A)[sp].[25r](C)[sp].[25r](G)[sp].[fR](U)[sp].[fR](A)[sp].[fR](C)[sp].[fR](G)[sp].[fR](U)p.[fR](A)p.[fR](C)p.[fR](G)p.[25r](U)p.[25r](A)p.[25r](C)p.[25r](G)}$$$$': 'UACGUACGUACGUACG'
 };
 
-export const helmToMolfile: Dict = {
-};
+export const helmToMolfile: Dict = {};
+/* eslint-enable max-len*/

package/src/tests/files-tests.ts

@@ -0,0 +1,75 @@
+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, expect, test} from '@datagrok-libraries/utils/src/test';
+import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
+
+import {getHelm} from './utils';
+
+import {_package} from '../package-test';
+import {ITranslationHelper} from '../types';
+
+category('files', () => {
+  let th: ITranslationHelper;
+
+  before(async () => {
+    th = await _package.getTranslationHelper();
+  });
+
+  test('list', async () => {
+    /** [subTest, success, format, src, res, tgt, error, stack ] */
+    let successCol: DG.Column<boolean>;
+    const resDf = DG.DataFrame.fromColumns([
+      DG.Column.string('subTest'),
+      successCol = DG.Column.bool('success'),
+      DG.Column.string('format'),
+      DG.Column.string('src'),
+      DG.Column.string('res'),
+      DG.Column.string('tgt'),
+      DG.Column.string('error'),
+      DG.Column.string('stack'),
+    ]);
+
+    const fiList = await _package.files.list('tests', true, '.csv');
+    for (const fi of fiList) {
+      const testDf = DG.DataFrame.fromCsv(await fi.readAsString());
+      const srcCol = testDf.columns.byIndex(0);
+      const format = srcCol.name;
+      const tgtCol = testDf.columns.byIndex(1);
+      const testDfRowCount = testDf.rowCount;
+      for (let rowIdx = 0; rowIdx < testDfRowCount; ++rowIdx) {
+        const row = resDf.rows.addNew();
+        row['subTest'] = `${fi.name}, row: ${rowIdx}`;
+        try {
+          const src = srcCol.get(rowIdx);
+          const tgt = tgtCol.get(rowIdx);
+          row['format'] = format;
+          row['src'] = src;
+          row['tgt'] = tgt;
+          const res = row['res'] = getHelm(src, format, th);
+          expect(res, tgt);
+          row['success'] = true;
+        } catch (err) {
+          const [errMsg, errStack] = errInfo(err);
+          row['error'] = errMsg;
+          row['stack'] = errStack;
+          row['success'] = false;
+        }
+      }
+    }
+
+    if (resDf.rowCount == 0) {
+      const emptyRow = resDf.rows.addNew(
+        ['empty', true, '', '']);
+    }
+
+    const failedTestIdx = successCol.toList().findIndex((s) => s != true);
+    if (failedTestIdx != -1) {
+      const fRow = resDf.rows.get(failedTestIdx);
+      throw new Error(`Subtest '${fRow['subTest']}' failed: ${fRow['error']}`);
+    }
+
+    return resDf;
+  }, {skipReason: 'Can not create test in async manner based on files in Shares.'});
+});

package/src/tests/formats-support.ts

@@ -1,19 +1,19 @@
-/* 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 {DEFAULT_FORMATS} from '../apps/common/model/const';
-import {loadJsonData} from '../apps/common/model/data-loader/json-loader';
-import {formatsToHelm} from './const';
-import {SequenceValidator} from '../apps/common/model/parsing-validation/sequence-validator';
 import {getTranslatedSequences} from '../apps/translator/model/conversion-utils';
-import {_package} from '../package';
+import {ITranslationHelper} from '../types';
+
+import {_package} from '../package-test';
+import {formatsToHelm} from './const';
 
-function getTranslationObject(sequence: string, format: string): {[format: string]: string} {
-  const indexOfInvalidChar = (new SequenceValidator(sequence)).getInvalidCodeIndex(format);
-  return getTranslatedSequences(sequence, indexOfInvalidChar, format);
+
+function getTranslationObject(sequence: string, format: string, th: ITranslationHelper): { [format: string]: string } {
+  const indexOfInvalidChar = th.createSequenceValidator(sequence).getInvalidCodeIndex(format);
+  return getTranslatedSequences(sequence, indexOfInvalidChar, format, th);
 }
 
 const inputs = {
@@ -22,14 +22,15 @@ const inputs = {
 };
 
 category('Formats support', () => {
+  let th: ITranslationHelper;
+
   before(async () => {
-    await loadJsonData();
-    await _package.initMonomerLib();
+    th = await _package.getTranslationHelper();
   });
 
   Object.entries(inputs).forEach(([format, sequence]) => {
     test(`All formats for ${format}`, async () => {
-      const output = getTranslationObject(sequence, format);
+      const output = getTranslationObject(sequence, format, th);
       const result = Object.keys(output).length;
       // +1 due to nucleotides
       const expected = Object.keys(formatsToHelm).length + 1;

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

@@ -1,34 +1,26 @@
-/* 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 {DEFAULT_FORMATS} from '../apps/common/model/const';
-import {FormatConverter} from '../apps/translator/model/format-converter';
-import {loadJsonData} from '../apps/common/model/data-loader/json-loader';
-import {formatsToHelm} from './const';
-import {_package} from '../package';
-
-function getHelm(strand: string, format: string): string {
-  return (new FormatConverter(strand, format).convertTo(DEFAULT_FORMATS.HELM));
-}
+import {getFormat, getHelm} from './utils';
+import {ITranslationHelper} from '../types';
 
-function getFromat(helm: string, format: string): string {
-  return (new FormatConverter(helm, DEFAULT_FORMATS.HELM).convertTo(format));
-}
+import {_package} from '../package-test';
+import {formatsToHelm} from './const';
 
 category('Formats to HELM', () => {
+  let th: ITranslationHelper;
+
   before(async () => {
-    await loadJsonData();
-    await _package.initMonomerLib();
+    th = await _package.getTranslationHelper();
   });
 
   for (const format of Object.keys(formatsToHelm)) {
     for (const [strand, helm] of Object.entries(formatsToHelm[format])) {
       test(`${format} to HELM`, async () => {
         const expected = helm;
-        const result = getHelm(strand, format);
+        const result = getHelm(strand, format, th);
         expect(result, expected);
       });
     }
@@ -36,16 +28,17 @@ category('Formats to HELM', () => {
 });
 
 category('HELM to Formats', () => {
+  let th: ITranslationHelper;
+
   before(async () => {
-    await loadJsonData();
-    await _package.initMonomerLib();
+    th = await _package.getTranslationHelper();
   });
 
   for (const format of Object.keys(formatsToHelm)) {
     for (const [strand, helm] of Object.entries(formatsToHelm[format])) {
       test(`${format} to HELM`, async () => {
         const expected = strand;
-        const result = getFromat(helm, format);
+        const result = getFormat(helm, format, th);
         expect(result, expected);
       });
     }

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

@@ -1,20 +1,26 @@
+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';
+import {ITranslationHelper} from '../types';
+
+import {_package} from '../package-test';
 import {helmToNucleotides} from './const';
-import {_package} from '../package';
-import {MonomerLibWrapper} from '../apps/common/model/monomer-lib/lib-wrapper';
+
 
 category('HELM to Nucleotides', () => {
+  let th: ITranslationHelper;
+
   before(async () => {
-    await loadJsonData();
-    await _package.initMonomerLib();
+    th = await _package.getTranslationHelper();
   });
 
   Object.entries(helmToNucleotides).forEach(([helm, nucleotide], idx) => {
     test(`Sequence ${idx + 1} to nucleotides`, async () => {
       const expected = nucleotide;
-      const result = getNucleotidesSequence(helm, MonomerLibWrapper.getInstance());
+      const result = getNucleotidesSequence(helm, th.monomerLibWrapper);
       expect(result, expected);
     });
   });

package/src/tests/utils.ts

@@ -0,0 +1,20 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {DEFAULT_FORMATS} from '../apps/common/model/const';
+import {ITranslationHelper} from '../types';
+
+export class OligoToolkitTestPackage extends DG.Package {
+  async getTranslationHelper(): Promise<ITranslationHelper> {
+    return (await grok.functions.call(`${this.name}:getTranslationHelper`)) as ITranslationHelper;
+  }
+}
+
+export function getHelm(strand: string, format: string, th: ITranslationHelper): string {
+  return th.createFormatConverter(strand, format).convertTo(DEFAULT_FORMATS.HELM);
+}
+
+export function getFormat(helm: string, format: string, th: ITranslationHelper): string {
+  return th.createFormatConverter(helm, DEFAULT_FORMATS.HELM).convertTo(format);
+}

package/src/types.ts

@@ -0,0 +1,18 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {JsonData} from './apps/common/model/data-loader/json-loader';
+import {MonomerLibWrapper} from './apps/common/model/monomer-lib/lib-wrapper';
+import {SequenceValidator} from './apps/common/model/parsing-validation/sequence-validator';
+import {FormatConverter} from './apps/translator/model/format-converter';
+import {FormatDetector} from './apps/common/model/parsing-validation/format-detector';
+
+export interface ITranslationHelper {
+  get jsonData(): JsonData;
+  get monomerLibWrapper(): MonomerLibWrapper;
+  createSequenceValidator(sequence: string): SequenceValidator;
+  createFormatConverter(sequence: string, sourceFormat: string): FormatConverter;
+  createFormatDetector(sequence: string): FormatDetector;
+  highlightInvalidSubsequence: (sequence: string) => HTMLSpanElement[];
+}

package/dist/package-test.js.LICENSE.txt

@@ -1,8 +0,0 @@
-/**
- * @license
- * Lodash <https://lodash.com/>
- * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
- * Released under MIT license <https://lodash.com/license>
- * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
- * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
- */