@datagrok/sequence-translator 1.3.0 → 1.3.2

package/files/monomers-sample/README.md

@@ -0,0 +1,12 @@
+Sample files of the package SequenceTranslator with samples of
+additional monomer libraries and dictionaries of substituting HELM substructures into sequences.
+
+codes-to-symbols.json: monomer codes in different formats corresponding to monomer symbols in monomer-lib.json
+
+formats-to-helm.json: monomer codes corresponding to helm substructures
+
+linkers.json: monomers containing phospate or phosphorothioate groups
+
+monomer-lib.json: pseudo-helm monomer library (R-groups are dummy)
+
+pattern-app-data.json: color maps for Pattern app

package/files/polytool-rules/rules_example.json

@@ -0,0 +1,34 @@
+[ 
+	{
+		"type": "link",
+		"code": "1",
+		"monomericSubstitution": {
+		    "firstMonomer": "C",
+		    "secondMonomer": "C",
+		    "firstLinkingGroup":"3",
+		    "secondLinkingGroup":"3",
+		    "firstSubstitution": "C",
+		    "secondSubstitution": "C"
+		}
+	},
+	{
+		"type": "link",
+		"code": "2",
+		"monomericSubstitution": {
+		    "firstMonomer": "NH2",
+		    "secondMonomer": "L",
+		    "firstLinkingGroup":"2",
+		    "secondLinkingGroup":"3",
+		    "firstSubstitution": "NH2",
+		    "secondSubstitution": "L"
+		}
+	},
+	{
+		"type": "fragmentDuplication",
+		"code": "#3"
+	},
+	{
+		"type": "differentFragments",
+		"code": "$4"
+	}
+]

package/files/samples/bulk-translation-axolabs.csv

@@ -0,0 +1,6 @@
+AxolabsSequences
+(GalNAc)AfCfpGfsUfacgu
+(GalNAc)UfCfpGfsUfacgu
+(GalNAc)CfCfpGfsUfacgu
+(GalNAc)AfCfsUfacgu
+(GalNAc)AfCfGfsUfacgu

package/files/tests/README.md

@@ -0,0 +1,2 @@
+Put here .csv files with columns `<format_name>` and `Helm` to extend tests 
+with sequences containing your custom monomers and substitution codes. 

package/files/tests/axolabs1.csv

@@ -0,0 +1,2 @@
+Axolabs,Helm
+AfCf,RNA1{[fR](A)p.[fR](C)}$$$$

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@datagrok/sequence-translator",
   "friendlyName": "Sequence Translator",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "author": {
     "name": "Alexey Choposky",
     "email": "achopovsky@datagrok.ai"
@@ -12,11 +12,20 @@
     "url": "https://github.com/datagrok-ai/public.git",
     "directory": "packages/SequenceTranslator"
   },
+  "properties": [
+    {
+      "name": "MonomersPath",
+      "description": "Path to additional monomer libraries and dictionaries of substituting HELM substructures into sequences",
+      "propertyType": "string",
+      "defaultValue": "System:AppData/SequenceTranslator/monomers",
+      "nullable": false
+    }
+  ],
   "dependencies": {
     "@datagrok-libraries/bio": "^5.41.9",
-    "@datagrok-libraries/chem-meta": "^1.2.3",
+    "@datagrok-libraries/chem-meta": "^1.2.5",
     "@datagrok-libraries/tutorials": "^1.3.12",
-    "@datagrok-libraries/utils": "^4.1.45",
+    "@datagrok-libraries/utils": "^4.2.6",
     "@types/react": "^18.0.15",
     "cash-dom": "^8.1.0",
     "datagrok-api": "^1.18.6",
@@ -25,12 +34,12 @@
     "openchemlib": "6.0.1",
     "save-svg-as-png": "^1.4.17",
     "ts-loader": "^9.3.1",
-    "typescript": "^5.4.2",
-    "typeahead-standalone": "4.14.1"
+    "typeahead-standalone": "4.14.1",
+    "typescript": "^5.4.2"
   },
   "devDependencies": {
-    "@datagrok/bio": "^2.12.0",
-    "@datagrok/chem": "1.9.0",
+    "@datagrok/bio": "^2.12.23",
+    "@datagrok/chem": "1.9.2",
     "@types/jquery": "^3.5.14",
     "@types/js-yaml": "^4.0.5",
     "@types/lodash": "^4.14.202",
@@ -40,6 +49,7 @@
     "@typescript-eslint/eslint-plugin": "^7.2.0",
     "@typescript-eslint/parser": "^7.2.0",
     "css-loader": "^6.7.3",
+    "datagrok-tools": "latest",
     "eslint": "^8.57.0",
     "eslint-config-google": "latest",
     "style-loader": "^3.3.1",
@@ -53,14 +63,14 @@
     "link-api": "npm link datagrok-api",
     "link-bio": "npm link @datagrok-libraries/bio",
     "link-all": "npm link @datagrok-libraries/chem-meta datagrok-api @datagrok-libraries/utils @datagrok-libraries/bio @datagrok-libraries/tutorials",
-    "debug-sequencetranslator": "grok publish",
-    "release-sequencetranslator": "grok publish localhost --release",
+    "debug-sequencetranslator": "webpack && grok publish",
+    "release-sequencetranslator": "webpack && grok publish --release",
     "build-sequencetranslator": "webpack",
     "build": "webpack",
-    "debug-sequencetranslator-public": "grok publish public",
-    "release-sequencetranslator-public": "grok publish public --release",
-    "debug-sequencetranslator-local": "grok publish local",
-    "release-sequencetranslator-local": "grok publish local --release",
+    "debug-sequencetranslator-public": "webpack && grok publish public",
+    "release-sequencetranslator-public": "webpack && grok publish public --release",
+    "debug-sequencetranslator-local": "webpack && grok publish local",
+    "release-sequencetranslator-local": "webpack && grok publish local --release",
     "lint": "eslint \"./src/**/*.ts\"",
     "lint-fix": "eslint \"./src/**/*.ts\" --fix",
     "test": "grok test",

package/src/apps/common/model/data-loader/const.ts

@@ -1,7 +1,6 @@
-export const LIB_PATH = 'System:AppData/SequenceTranslator';
+export const FALLBACK_LIB_PATH = 'System:AppData/SequenceTranslator/monomers-sample';
 export const DEFAULT_LIB_FILENAME = 'monomer-lib.json';
 
-export const APP_PATH = 'System:AppData/SequenceTranslator';
 export const PATTERN_APP_DATA_FILENAME = 'pattern-app-data.json';
 export const CODES_TO_HELM_DICT_FILENAME = 'formats-to-helm.json';
 export const CODES_TO_SYMBOLS_FILENAME = 'codes-to-symbols.json';

package/src/apps/common/model/data-loader/json-loader.ts

@@ -1,48 +1,39 @@
 /* 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 {
-  APP_PATH, PATTERN_APP_DATA_FILENAME, CODES_TO_HELM_DICT_FILENAME,
+  PATTERN_APP_DATA_FILENAME, CODES_TO_HELM_DICT_FILENAME,
   CODES_TO_SYMBOLS_FILENAME, MONOMERS_WITH_PHOSPHATE_FILENAME
 } from './const';
 import {PatternAppData, CodeToSymbol, FormatToHELMDict} from './types';
 
-const fileSource = new DG.FileSource(APP_PATH);
-
-export let PATTERN_APP_DATA: PatternAppData;
-export let CODES_TO_HELM_DICT: FormatToHELMDict;
-export let CODES_TO_SYMBOLS_DICT: CodeToSymbol;
-export let MONOMERS_WITH_PHOSPHATE: {[key: string]: string[]};
-
-export async function loadJsonData(): Promise<void> {
-  if (isAllJsonDataLoaded())
-    return;
-
-  const jsonFileNames = [
-    PATTERN_APP_DATA_FILENAME, CODES_TO_HELM_DICT_FILENAME, CODES_TO_SYMBOLS_FILENAME, MONOMERS_WITH_PHOSPHATE_FILENAME
-  ];
+export class JsonData {
+  constructor(
+    public readonly patternAppData: PatternAppData,
+    public readonly codesToHelmDict: FormatToHELMDict,
+    public readonly codesToSymbolsDict: CodeToSymbol,
+    public readonly monomersWithPhosphate: { [key: string]: string[] }
+  ) {};
+}
 
-  [
-    PATTERN_APP_DATA,
-    CODES_TO_HELM_DICT,
-    CODES_TO_SYMBOLS_DICT,
-    MONOMERS_WITH_PHOSPHATE
-  ] = await Promise.all(
-    jsonFileNames.map((fileName) => loadAndParseJson(fileName))
+export async function loadJsonData(monomersPath: string): Promise<JsonData> {
+  const data = await Promise.all(
+    [
+      PATTERN_APP_DATA_FILENAME, CODES_TO_HELM_DICT_FILENAME,
+      CODES_TO_SYMBOLS_FILENAME, MONOMERS_WITH_PHOSPHATE_FILENAME
+    ].map((fileName) => loadAndParseJson(monomersPath, fileName))
   );
+  return new JsonData(data[0], data[1], data[2], data[3]);
 }
 
-async function loadAndParseJson(filePath: string): Promise<any> {
+async function loadAndParseJson(path: string, fileName: string): Promise<any> {
+  const filePath = path.endsWith('/') ? `${path}${fileName}` : `${path}/${fileName}`;
   try {
-    const content = await fileSource.readAsText(filePath);
+    const content = await grok.dapi.files.readAsText(filePath);
     return JSON.parse(content);
   } catch (err) {
-    console.error(`Error loading json from ${filePath}:`, err);
+    console.error(`Error loading json from '${filePath}':`, err);
   }
 }
-
-function isAllJsonDataLoaded(): boolean {
-  const data = [PATTERN_APP_DATA, CODES_TO_HELM_DICT, CODES_TO_SYMBOLS_DICT, MONOMERS_WITH_PHOSPHATE];
-
-  return data.every((item) => item !== undefined);
-}

package/src/apps/common/model/monomer-lib/lib-wrapper.ts

@@ -7,23 +7,23 @@ import {IMonomerLib, Monomer} from '@datagrok-libraries/bio/src/types';
 import {HELM_REQUIRED_FIELD as REQ, HELM_OPTIONAL_FIELDS as OPT} from '@datagrok-libraries/bio/src/utils/const';
 
 import {META_FIELDS as MET} from './const';
-import {CODES_TO_SYMBOLS_DICT} from '../data-loader/json-loader';
+import {JsonData} from '../data-loader/json-loader';
 
 export class MonomerLibWrapper {
-  private constructor() {
-    const lib = _package.monomerLib;
-    if (lib === null)
+  public constructor(
+    private readonly lib: IMonomerLib,
+    private readonly jsonData: JsonData
+  ) {
+    if (this.lib === null)
       throw new Error('SequenceTranslator: monomer library is null');
-    this.lib = lib!;
     this.allMonomers = this.getAllMonomers();
   }
 
-  private lib: IMonomerLib;
   private static instance?: MonomerLibWrapper;
   private allMonomers: Monomer[];
 
-  private formatMonomerForViewer(sourceObj: Monomer): {[key: string]: string} {
-    const formattedObject: {[key: string]: string} = {};
+  private formatMonomerForViewer(sourceObj: Monomer): { [key: string]: string } {
+    const formattedObject: { [key: string]: string } = {};
     formattedObject[REQ.NAME] = sourceObj[REQ.SYMBOL];
     formattedObject[REQ.SYMBOL] = sourceObj[REQ.SYMBOL];
     formattedObject[REQ.MOLFILE] = sourceObj[REQ.MOLFILE];
@@ -31,7 +31,7 @@ export class MonomerLibWrapper {
     formats.forEach((format) => {
       if (format === DEFAULT_FORMATS.HELM)
         return;
-      const map = CODES_TO_SYMBOLS_DICT[format];
+      const map = this.jsonData.codesToSymbolsDict[format];
       const codes = Object.keys(map).filter((code) => map[code] === sourceObj.symbol);
       formattedObject[format] = codes.join(', ');
     });
@@ -59,12 +59,6 @@ export class MonomerLibWrapper {
     return monomer!;
   }
 
-  static getInstance(): MonomerLibWrapper {
-    if (MonomerLibWrapper.instance === undefined)
-      MonomerLibWrapper.instance = new MonomerLibWrapper();
-    return MonomerLibWrapper.instance!;
-  }
-
   getMolfileBySymbol(monomerSymbol: string): string {
     const monomer = this.getMonomer(monomerSymbol);
     return monomer.molfile;
@@ -85,15 +79,15 @@ export class MonomerLibWrapper {
   }
 
   getCodeToSymbolMap(format: string): Map<string, string> {
-    return new Map<string, string>(Object.entries(CODES_TO_SYMBOLS_DICT[format]));
+    return new Map<string, string>(Object.entries(this.jsonData.codesToSymbolsDict[format]));
   }
 
   getCodesByFormat(format: string): string[] {
-    return Object.keys(CODES_TO_SYMBOLS_DICT[format]);
+    return Object.keys(this.jsonData.codesToSymbolsDict[format]);
   }
 
   getAllFormats(): string[] {
-    return Object.keys(CODES_TO_SYMBOLS_DICT);
+    return Object.keys(this.jsonData.codesToSymbolsDict);
   }
 
   getTableForViewer(): DG.DataFrame {
@@ -104,7 +98,7 @@ export class MonomerLibWrapper {
 
   getCodesToWeightsMap(): Map<string, number> {
     const codesToWeightsMap = new Map<string, number>();
-    Object.entries(CODES_TO_SYMBOLS_DICT).forEach(([_, dict]) => {
+    Object.entries(this.jsonData.codesToSymbolsDict).forEach(([_, dict]) => {
       Object.entries(dict).forEach(([code, monomerSymbol]) => {
         const monomer = this.getMonomer(monomerSymbol);
         const weight = monomer[OPT.META]?.[MET.MOLWEIGHT];

package/src/apps/common/model/oligo-toolkit-package.ts

@@ -1,30 +1,97 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
-import {IMonomerLib} from '@datagrok-libraries/bio/src/types';
+import {IMonomerLib, Monomer} from '@datagrok-libraries/bio/src/types';
 
 import {APP_NAME} from '../view/const';
-import {DEFAULT_LIB_FILENAME, LIB_PATH} from './data-loader/const';
+import {DEFAULT_LIB_FILENAME, FALLBACK_LIB_PATH} from './data-loader/const';
 import {tryCatch} from './helpers';
+import {ITranslationHelper} from '../../../types';
+import {SequenceValidator} from './parsing-validation/sequence-validator';
+import {JsonData, loadJsonData} from './data-loader/json-loader';
+import {MonomerLibWrapper} from './monomer-lib/lib-wrapper';
+import {_package} from '../../../package';
+import {FormatConverter} from '../../translator/model/format-converter';
+import {FormatDetector} from './parsing-validation/format-detector';
+import {highlightInvalidSubsequence} from '../view/components/colored-input/input-painters';
 
-export class OligoToolkitPackage extends DG.Package {
+export class OligoToolkitPackage extends DG.Package implements ITranslationHelper {
   private _monomerLib?: IMonomerLib;
-
   get monomerLib(): IMonomerLib {
     if (!this._monomerLib)
       throw new Error('Monomer lib not loaded');
     return this._monomerLib!;
   }
 
-  async initMonomerLib(): Promise<void> {
-    if (this._monomerLib !== undefined)
-      return;
+  private _jsonData: JsonData;
+  get jsonData(): JsonData {
+    if (!this._jsonData)
+      throw new Error('Json data not loaded');
+    return this._jsonData;
+  }
+
+  private _monomerLibWrapper: MonomerLibWrapper;
+  get monomerLibWrapper(): MonomerLibWrapper {
+    if (!this._monomerLibWrapper)
+      throw new Error('Monomer lib wrapper not loaded');
+    return this._monomerLibWrapper;
+  }
+
+  constructor() {
+    super();
+  }
+
+  private initPromise?: Promise<void>;
+
+  async initLibData(): Promise<void> {
+    if (!this.initPromise) {
+      this.initPromise = (async () => {
+        const packageSettings = await this.getSettings();
+        let monomersPath: string = packageSettings['MonomersPath'];
+        if (!monomersPath || !(await grok.dapi.files.exists(monomersPath))) {
+          _package.logger.warning(`Monomers path '${monomersPath}' not found. ` +
+            `Fallback to monomers sample path '${FALLBACK_LIB_PATH}'.`);
+          monomersPath = FALLBACK_LIB_PATH;
+        }
+        [this._jsonData, this._monomerLib] = await Promise.all([
+          loadJsonData(monomersPath),
+          loadMonomerLib(monomersPath)
+        ]);
+        this._monomerLibWrapper = new MonomerLibWrapper(this.monomerLib, this.jsonData);
+      })();
+    }
+    return this.initPromise;
+  }
+
+  async getTranslationHelper(): Promise<ITranslationHelper> {
+    return (await grok.functions.call(`${this.name}:getTranslationHelper`)) as ITranslationHelper;
+  }
 
-    const pi: DG.TaskBarProgressIndicator = DG.TaskBarProgressIndicator.create(
-      `Initializing ${APP_NAME.COMBINED} monomer library ...`);
-    await tryCatch(async () => {
-      const libHelper: IMonomerLibHelper = await getMonomerLibHelper();
-      this._monomerLib = await libHelper.readLibrary(LIB_PATH, DEFAULT_LIB_FILENAME);
-    }, () => pi.close());
+  createSequenceValidator(sequence: string): SequenceValidator {
+    return new SequenceValidator(sequence, this);
   }
+
+  createFormatConverter(sequence: string, sourceFormat: string): FormatConverter {
+    return new FormatConverter(sequence, sourceFormat, this);
+  }
+
+  createFormatDetector(sequence: string): FormatDetector {
+    return new FormatDetector(sequence, this);
+  }
+
+  highlightInvalidSubsequence = (input: string): HTMLSpanElement[] => {
+    return highlightInvalidSubsequence(input, this);
+  };
+}
+
+async function loadMonomerLib(monomersPath: string): Promise<IMonomerLib> {
+  const pi: DG.TaskBarProgressIndicator = DG.TaskBarProgressIndicator.create(
+    `Initializing ${APP_NAME.COMBINED} monomer library ...`);
+  try {
+    const libHelper = await getMonomerLibHelper();
+    const res = await libHelper.readLibrary(monomersPath, DEFAULT_LIB_FILENAME);
+    return res;
+  } finally { pi.close(); }
 }

package/src/apps/common/model/parsing-validation/format-detector.ts

@@ -6,13 +6,16 @@ import * as DG from 'datagrok-api/dg';
 import {sortByReverseLength} from '../helpers';
 import {DEFAULT_FORMATS} from '../const';
 import {MonomerLibWrapper} from '../monomer-lib/lib-wrapper';
-import {CODES_TO_HELM_DICT} from '../data-loader/json-loader';
-import {SequenceValidator} from './sequence-validator';
+
+import {ITranslationHelper} from '../../../../types';
 
 export class FormatDetector {
-  constructor(private sequence: string) {
-    this.libWrapper = MonomerLibWrapper.getInstance();
-    this.formats = Object.keys(CODES_TO_HELM_DICT);
+  constructor(
+    private sequence: string,
+    private readonly th: ITranslationHelper,
+  ) {
+    this.libWrapper = this.th.monomerLibWrapper;
+    this.formats = Object.keys(this.th.jsonData.codesToHelmDict);
   };
 
   private libWrapper: MonomerLibWrapper;
@@ -26,7 +29,7 @@ export class FormatDetector {
     if (possibleFormats.length === 0)
       return null;
 
-    const validator = new SequenceValidator(this.sequence);
+    const validator = this.th.createSequenceValidator(this.sequence);
     const outputIndices = Array(possibleFormats.length).fill(0);
     for (let i = 0; i < possibleFormats.length; ++i) {
       const format = possibleFormats[i];

package/src/apps/common/model/parsing-validation/format-handler.ts

@@ -3,15 +3,17 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {CODES_TO_HELM_DICT} from '../data-loader/json-loader';
 import {CodesInfo} from '../data-loader/types';
 import {DEFAULT_FORMATS} from '../const';
+import {ITranslationHelper} from '../../../../types';
 import {GROUP_TYPE, PHOSPHATE_SYMBOL} from '../../../translator/model/const';
 
 const inverseLengthComparator = (a: string, b: string) => b.length - a.length;
 
 export class FormatHandler {
-  constructor() {
+  constructor(
+    private readonly th: ITranslationHelper,
+  ) {
     this.formats = this.getFormats();
   }
 
@@ -31,19 +33,19 @@ export class FormatHandler {
     return this.getFormatCodes(format);
   }
 
-  getHelmToFormatDict(format: string): {[key: string]: string} {
+  getHelmToFormatDict(format: string): { [key: string]: string } {
     this.validateFormat(format);
 
-    const codesInfoObject = CODES_TO_HELM_DICT[format] as CodesInfo;
+    const codesInfoObject = this.th.jsonData.codesToHelmDict[format] as CodesInfo;
     const dict = getHelmToCodeDict(codesInfoObject);
     return dict;
   }
 
-  getFormatToHelmDict(format: string): {[key: string]: string} {
+  getFormatToHelmDict(format: string): { [key: string]: string } {
     this.validateFormat(format);
 
-    const codesInfoObject = CODES_TO_HELM_DICT[format] as CodesInfo;
-    const dict = Object.assign({}, ...Object.values(codesInfoObject)) as {[code: string]: string};
+    const codesInfoObject = this.th.jsonData.codesToHelmDict[format] as CodesInfo;
+    const dict = Object.assign({}, ...Object.values(codesInfoObject)) as { [code: string]: string };
     return dict;
   }
 
@@ -75,7 +77,7 @@ export class FormatHandler {
   getPhosphateHelmCodesRegExp(format: string): RegExp {
     this.validateFormat(format);
 
-    const codesInfoObject = CODES_TO_HELM_DICT[format] as CodesInfo;
+    const codesInfoObject = this.th.jsonData.codesToHelmDict[format] as CodesInfo;
     const phosphateHELMCodes = Array.from(
       new Set(Object.values(codesInfoObject[GROUP_TYPE.LINKAGE]))
     ).sort(inverseLengthComparator);
@@ -89,7 +91,7 @@ export class FormatHandler {
   }
 
   private getFormats(): string[] {
-    return Object.keys(CODES_TO_HELM_DICT);
+    return Object.keys(this.th.jsonData.codesToHelmDict);
   }
 
   private validateFormat(format: string) {
@@ -109,7 +111,8 @@ export class FormatHandler {
 
   private getNonHelmFormatRegExp(format: string): RegExp {
     const formatCodes = this.getCodesByFormat(format);
-    const formatRegExp = new RegExp(getRegExpPattern(formatCodes) + '|\\([^()]*\\)|.', 'g'); // the added group before '|.' is to avoid mismatch inside parenths
+    // the added group before '|.' is to avoid mismatch inside parenthesis
+    const formatRegExp = new RegExp(getRegExpPattern(formatCodes) + '|\\([^()]*\\)|.', 'g');
     return formatRegExp;
   }
 }
@@ -128,8 +131,8 @@ export function getRegExpPattern(arr: string[]): string {
 }
 
 function getHelmToCodeDict(infoObj: CodesInfo) {
-  const result: {[key: string]: string | string[]} = {};
-  Object.values(infoObj).forEach((obj: {[code: string]: string}) => {
+  const result: { [key: string]: string | string[] } = {};
+  Object.values(infoObj).forEach((obj: { [code: string]: string }) => {
     Object.entries(obj).forEach(([code, helm]) => {
       const key = helm.replace(/\)p/g, ')').replace(/\]p/g, ']');
       if (result[key] === undefined)
@@ -142,5 +145,5 @@ function getHelmToCodeDict(infoObj: CodesInfo) {
     const sorted = (value as string[]).sort(inverseLengthComparator);
     result[key] = sorted[0] as string;
   });
-  return result as {[key: string]: string};
+  return result as { [key: string]: string };
 }

package/src/apps/common/model/parsing-validation/sequence-validator.ts

@@ -2,13 +2,18 @@ import {NUCLEOTIDES} from '../const';
 import {MonomerLibWrapper} from '../monomer-lib/lib-wrapper';
 import {sortByReverseLength} from '../helpers';
 import {DEFAULT_FORMATS} from '../const';
+import {ITranslationHelper} from '../../../../types';
 
 export class SequenceValidator {
-  constructor(private sequence: string) {
-    this.libWrapper = MonomerLibWrapper.getInstance();
-  };
   private libWrapper: MonomerLibWrapper;
 
+  constructor(
+    private readonly sequence: string,
+    private readonly th: ITranslationHelper,
+  ) {
+    this.libWrapper = this.th.monomerLibWrapper;
+  };
+
   getInvalidCodeIndex(format: string): number {
     if (format === DEFAULT_FORMATS.HELM)
       return this.sequence.length;

package/src/apps/common/view/combined-app-ui.ts

@@ -9,32 +9,34 @@ import {OligoTranslatorUI} from '../../translator/view/ui';
 import {AppUIBase} from './app-ui-base';
 import {IsolatedAppUIBase} from './isolated-app-ui';
 import {APP_NAME, TAB_NAME} from './const';
+import {ITranslationHelper} from '../../../types';
 
-type ViewFactories = {[name: string]: () => DG.View};
+type ViewFactories = { [name: string]: () => DG.View };
 
 export class CombinedAppUI extends AppUIBase {
-  constructor(externalViewFactories: ViewFactories) {
+  constructor(
+    private readonly externalViewFactories: ViewFactories,
+    private readonly th: ITranslationHelper
+  ) {
     super(APP_NAME.COMBINED);
-    this.externalViewFactories = externalViewFactories;
-    const factories = this.getViewFactories();
+
+    const factories = this.getViewFactories(this.th);
     this.multiView = new DG.MultiView({viewFactories: factories});
   }
 
   private multiView: DG.MultiView;
-  private externalViewFactories?: ViewFactories;
-
 
-  private getViewFactories(): ViewFactories {
-    function viewFactory(UiConstructor: new (view: DG.View) => IsolatedAppUIBase): () => DG.View {
+  private getViewFactories(th: ITranslationHelper): ViewFactories {
+    function viewFactory(UiConstructor: new (th: ITranslationHelper) => IsolatedAppUIBase): () => DG.View {
       const view = DG.View.create();
-      const translateUI = new UiConstructor(view);
+      const translateUI = new UiConstructor(th);
       translateUI.initView().catch(
         (e) => console.error(`Failed to initialize ${UiConstructor.name}: ${e}`)
       );
       return () => translateUI.getView();
     }
 
-    let result: {[key: string]: () => DG.View } = {
+    let result: { [key: string]: () => DG.View } = {
       [TAB_NAME.TRANSLATOR]: viewFactory(OligoTranslatorUI),
       [TAB_NAME.PATTERN]: viewFactory(OligoPatternUI),
       [TAB_NAME.STRUCTURE]: viewFactory(OligoStructureUI),

package/src/apps/common/view/components/colored-input/input-painters.ts

@@ -7,6 +7,7 @@ import {SequenceValidator} from '../../../model/parsing-validation/sequence-vali
 import {FormatDetector} from '../../../model/parsing-validation/format-detector';
 
 import $ from 'cash-dom';
+import {ITranslationHelper} from '../../../../../types';
 
 /** Set different colors for letters, can be upgraded to color various monomers */
 export function demoPainter(input: string): HTMLSpanElement[] {
@@ -24,12 +25,12 @@ export function demoPainter(input: string): HTMLSpanElement[] {
 }
 
 // todo: port to another place
-export function highlightInvalidSubsequence(input: string): HTMLSpanElement[] {
+export function highlightInvalidSubsequence(input: string, th: ITranslationHelper): HTMLSpanElement[] {
   // validate sequence
   let cutoff = 0;
-  const format = (new FormatDetector(input)).getFormat();
+  const format = th.createFormatDetector(input).getFormat();
   if (format !== null)
-    cutoff = (new SequenceValidator(input)).getInvalidCodeIndex(format!);
+    cutoff = (new SequenceValidator(input, th)).getInvalidCodeIndex(format!);
   const isValid = cutoff < 0 || input === '';
   const greyTextSpan = ui.span([]);
   $(greyTextSpan).css('-webkit-text-fill-color', 'var(--grey-6)');

package/src/apps/common/view/monomer-lib-viewer.ts

@@ -5,10 +5,11 @@ import * as DG from 'datagrok-api/dg';
 
 import {drawZoomedInMolecule} from './components/draw-molecule';
 import {MonomerLibWrapper} from '../model/monomer-lib/lib-wrapper';
+import {_package} from '../../../package';
 
 export class MonomerLibViewer {
   static async view(): Promise<void> {
-    const table = MonomerLibWrapper.getInstance().getTableForViewer();
+    const table = _package.monomerLibWrapper.getTableForViewer();
     table.name = 'Monomer Library';
     const view = grok.shell.addTableView(table);
     view.grid.props.allowEdit = false;