@datagrok/sequence-translator 1.0.17 → 1.1.4

package/src/model/axolabs/axolabs-tab.ts

@@ -0,0 +1,111 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+// @ts-ignore
+import * as svg from 'save-svg-as-png';
+import $ from 'cash-dom';
+
+import {isOverhang} from './helpers';
+import {axolabsStyleMap} from '../data-loading-utils/json-loader';
+
+export function generateExample(sequenceLength: number, sequenceBasis: string): string {
+  const AXOLABS_MAP = axolabsStyleMap;
+  const uniqueSymbols = AXOLABS_MAP[sequenceBasis].symbols.join('');
+  return uniqueSymbols.repeat(Math.floor(sequenceLength / 4)) + uniqueSymbols.slice(0, sequenceLength % 4);
+}
+
+export function findDuplicates(data: Int32Array | Float32Array | Float64Array | Uint32Array): number[] {
+  return Array.from(new Set(data)).filter((value) => data.indexOf(value) !== data.lastIndexOf(value));
+}
+
+export async function isCurrentUserCreatedThisPattern(patternName: string): Promise<boolean> {
+  return await grok.dapi.users.current().then((user) => {
+    const [firstName, lastName] = getUserName(patternName);
+    return (user.firstName !== firstName || user.lastName !== lastName);
+  });
+}
+
+export function getShortName(patternName: string): string {
+  let first = patternName.length + 1;
+  for (let i = 0; i < patternName.length; i++) {
+    if (patternName[i] === '(') {
+      first = i;
+      break;
+    }
+  }
+  return patternName.slice(0, first - 1);
+}
+
+function getUserName(patternName: string): string[] {
+  let first = -1;
+  for (let i = 0; i < patternName.length; i++) {
+    if (patternName[i] === '(') {
+      first = i;
+      break;
+    }
+  }
+  return (first === -1) ? ['', ''] : patternName.slice(first + 9, patternName.length - 1).split(' ').slice(1);
+}
+
+export function translateSequence(
+  sequence: string,
+  bases: DG.InputBase[],
+  ptoLinkages: DG.InputBase[],
+  startModification: DG.InputBase,
+  endModification: DG.InputBase,
+  firstPtoExist: boolean): string {
+  let i: number = -1;
+  let mainSequence = sequence.replace(/[AUGC]/g, function(x: string) {
+    i++;
+    const AXOLABS_MAP = axolabsStyleMap;
+
+    const baseChoices: string[] = Object.keys(AXOLABS_MAP);
+    // const defaultBase: string = baseChoices[0];
+    const indexOfSymbol = AXOLABS_MAP['RNA']['symbols'].indexOf(x);
+    let symbol = AXOLABS_MAP[bases[i].value]['symbols'][indexOfSymbol];
+    if (isOverhang(bases[i].value)) {
+      if (i < sequence.length / 2 && !isOverhang(bases[i + 1].value))
+        symbol = symbol + x + 'f';
+      else if (i > sequence.length / 2 && !isOverhang(bases[i - 1].value))
+        symbol = x + 'f' + symbol;
+    }
+    return (ptoLinkages[i].value) ? symbol + 's' : symbol;
+  });
+  if (mainSequence.slice(0, 5).split('mU').length === 3)
+    mainSequence = '(uu)' + mainSequence.slice(4);
+  if (mainSequence.slice(mainSequence.length - 7).split('mU').length === 3)
+    mainSequence = mainSequence.slice(0, mainSequence.length - 4) + '(uu)';
+  return startModification.value + (firstPtoExist ? 's' : '') + mainSequence + endModification.value;
+}
+
+export function addColumnWithIds(tableName: string, columnName: string, patternName: string) {
+  const nameOfNewColumn = 'ID ' + patternName;
+  const columns = grok.shell.table(tableName).columns;
+  if (columns.contains(nameOfNewColumn))
+    columns.remove(nameOfNewColumn);
+  const columnWithIds = columns.byName(columnName);
+  return columns.addNewString(nameOfNewColumn).init((i: number) => {
+    return (columnWithIds.getString(i) === '') ? '' : columnWithIds.get(i) + '_' + patternName;
+  });
+}
+
+export function addColumnWithTranslatedSequences(
+  tableName: string,
+  columnName: string,
+  bases: DG.InputBase[],
+  ptoLinkages: DG.InputBase[],
+  startModification: DG.InputBase,
+  endModification: DG.InputBase,
+  firstPtoExist: boolean) {
+  const nameOfNewColumn = 'Axolabs ' + columnName;
+  const columns = grok.shell.table(tableName).columns;
+  if (columns.contains(nameOfNewColumn))
+    columns.remove(nameOfNewColumn);
+  const columnWithInputSequences = columns.byName(columnName);
+  return columns.addNewString(nameOfNewColumn).init((i: number) => {
+    return columnWithInputSequences.getString(i) === '' ?
+      '' :
+      translateSequence(columnWithInputSequences.getString(i), bases, ptoLinkages, startModification, endModification,
+        firstPtoExist);
+  });
+}

package/src/model/axolabs/const.ts

@@ -0,0 +1,33 @@
+export const DEFAULT_PTO: boolean = true;
+export const DEFAULT_SEQUENCE_LENGTH: number = 23;
+export const MAX_SEQUENCE_LENGTH: number = 35;
+export const USER_STORAGE_KEY: string = 'SequenceTranslator';
+export const EXAMPLE_MIN_WIDTH: string = '400px';
+
+export const enum JSON_FIELD {
+  SS_BASES = 'ssBases',
+  AS_BASES = 'asBases',
+  SS_PTO = 'ssPtoLinkages',
+  AS_PTO = 'asPtoLinkages',
+  SS_3 = 'ssThreeModification',
+  SS_5 = 'ssFiveModification',
+  AS_3 = 'asThreeModification',
+  AS_5 = 'asFiveModification',
+  COMMENT = 'comment',
+};
+
+export const SS = 'SS' as const;
+export const AS = 'AS' as const;
+export const STRANDS = [SS, AS];
+export const STRAND_NAME = {
+  [SS]: 'Sense strand',
+  [AS]: 'Anti sense',
+}
+
+export const THREE_PRIME = 'THREE_PRIME' as const;
+export const FIVE_PRIME = 'FIVE_PRIME' as const;
+export const TERMINAL_KEYS = [THREE_PRIME, FIVE_PRIME];
+export const TERMINAL = {
+  [THREE_PRIME]: 3,
+  [FIVE_PRIME]: 5,
+}

package/src/{axolabs-tab → model/axolabs}/draw-svg.ts

@@ -1,4 +1,4 @@
-import {NUCLEOTIDES} from '../hardcode-to-be-eliminated/map';
+import {NUCLEOTIDES} from '../const';
 import {isOverhang, svg, textWidth, countOverhangsOnTheRightEdge, baseColor, textInsideCircle,
   fontColorVisibleOnBackground, isOneDigitNumber} from './helpers';
 

package/src/{axolabs-tab → model/axolabs}/helpers.ts

@@ -1,8 +1,8 @@
-import {AXOLABS_MAP} from '../hardcode-to-be-eliminated/constants';
-import {NUCLEOTIDES} from '../hardcode-to-be-eliminated/map';
+import {NUCLEOTIDES} from '../const';
+import {axolabsStyleMap} from '../data-loading-utils/json-loader';
 
 export function isOverhang(modification: string): boolean {
-  return modification.slice(-3) == '(o)';
+  return modification.slice(-3) === '(o)';
 }
 
 export function isOneDigitNumber(n: number): boolean {
@@ -21,7 +21,7 @@ export function getPointsToDrawStar(centerX: number, centerY: number): string {
 
   let points = '';
   for (let i = 0; i < totalNumberOfPoints; i++) {
-    const r = (i % 2 == 0) ? outerRadius : innerRadius;
+    const r = (i % 2 === 0) ? outerRadius : innerRadius;
     const currentX = centerX + Math.cos(i * angle + angleOffsetToCenterStar) * r;
     const currentY = centerY + Math.sin(i * angle + angleOffsetToCenterStar) * r;
     points += `${currentX},${currentY} `;
@@ -33,7 +33,7 @@ export function countOverhangsOnTheRightEdge(modifications: string[]): number {
   let i = 0;
   while (i < modifications.length && isOverhang(modifications[i]))
     i++;
-  return (i == modifications.length - 1) ? 0 : i;
+  return (i === modifications.length - 1) ? 0 : i;
 }
 
 export function textWidth(text: string, font: number): number {
@@ -49,11 +49,13 @@ export function textInsideCircle(bases: string[], index: number): string {
 }
 
 export function fontColorVisibleOnBackground(base: string): string {
+  const AXOLABS_MAP = axolabsStyleMap;
   const rgbIntList = AXOLABS_MAP[base].color.match(/\d+/g)!.map((e) => Number(e));
   return (rgbIntList[0] * 0.299 + rgbIntList[1] * 0.587 + rgbIntList[2] * 0.114) > 186 ? '#33333' : '#ffffff';
 }
 
 export function baseColor(base: string): string {
+  const AXOLABS_MAP = axolabsStyleMap;
   return AXOLABS_MAP[base].color;
 }
 

package/src/model/const.ts

@@ -0,0 +1,18 @@
+/* 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';
+
+export const NUCLEOTIDES = ['A', 'G', 'C', 'U', 'T'];
+
+export const TECHNOLOGIES = {
+  DNA: 'DNA',
+  RNA: 'RNA',
+  ASO_GAPMERS: 'ASOGapmers',
+  SI_RNA: 'siRNA',
+};
+
+export enum DEFAULT_FORMATS {
+  HELM = 'HELM',
+  AXOLABS = 'Axolabs',
+}

package/src/model/data-loading-utils/const.ts

@@ -0,0 +1,8 @@
+export const LIB_PATH = 'System:AppData/SequenceTranslator';
+export const DEFAULT_LIB_FILENAME = 'monomer-lib.json';
+
+export const APP_PATH = 'System:AppData/SequenceTranslator';
+export const AXOLABS_STYLE_FILENAME = 'axolabs-style.json';
+export const CODES_TO_HELM_DICT_FILENAME = 'formats-to-helm.json';
+export const CODES_TO_SYMBOLS_FILENAME = 'codes-to-symbols.json';
+export const MONOMERS_WITH_PHOSPHATE_LINKERS = 'linkers.json';

package/src/model/data-loading-utils/json-loader.ts

@@ -0,0 +1,38 @@
+/* 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, AXOLABS_STYLE_FILENAME, CODES_TO_HELM_DICT_FILENAME, CODES_TO_SYMBOLS_FILENAME, MONOMERS_WITH_PHOSPHATE_LINKERS} from './const';
+import {AxolabsStyle, FormatToHELMDict, CodeToSymbol} from './types';
+
+const fileSource = new DG.FileSource(APP_PATH);
+
+export let axolabsStyleMap: AxolabsStyle;
+export let codesToHelmDictionary: FormatToHELMDict;
+export let codesToSymbolsDictionary: CodeToSymbol;
+export let monomersWithPhosphateLinkers: {[key: string]: string[]};
+
+export async function getJsonData(): Promise<void> {
+  const data = [axolabsStyleMap, codesToHelmDictionary, codesToSymbolsDictionary, monomersWithPhosphateLinkers];
+
+  if (data.every((item) => item !== undefined))
+    return;
+
+  axolabsStyleMap = await parse(AXOLABS_STYLE_FILENAME);
+  codesToHelmDictionary = await parse(CODES_TO_HELM_DICT_FILENAME);
+  codesToSymbolsDictionary = await parse(CODES_TO_SYMBOLS_FILENAME);
+  monomersWithPhosphateLinkers = await parse(MONOMERS_WITH_PHOSPHATE_LINKERS);
+}
+
+async function parse(path: string): Promise<any> {
+  let parsedJson: string;
+  try {
+    parsedJson = JSON.parse(await fileSource.readAsText(path))
+  } catch (err: any) {
+    const errMsg: string = err.hasOwnProperty('message') ? err.message : err.toString();
+    throw new Error(`Error loading json from ${path}:` + errMsg);
+  }
+  return parsedJson;
+}
+

package/src/model/data-loading-utils/types.ts

@@ -0,0 +1,30 @@
+type KeyToValue = {[key: string]: string};
+
+export type Edges = {
+  [key: string]: KeyToValue
+}
+
+export type AxolabsStyle = {
+  [index: string]: {
+    fullName: string,
+    symbols: string[],
+    color: string,
+  }
+};
+
+export type CodesInfo = {
+    [key: string]: { // nucleoside or phosphate
+      [code: string]: string
+    }
+  }
+
+
+export type FormatToHELMDict = {
+  [sourceFormat: string]: CodesInfo
+}
+
+export type CodeToSymbol = {
+  [format: string]: {
+    [code: string]: string
+  }
+}

package/src/model/format-translation/const.ts

@@ -0,0 +1,8 @@
+export const GROUP_TYPE = {
+  NUCLEOSIDE: 'nucleoside',
+  LINKAGE: 'phosphateBackbone',
+} as const;
+
+export const PHOSPHATE_SYMBOL = 'p';
+
+export const UNKNOWN_SYMBOL = '<?>';

package/src/model/format-translation/conversion-utils.ts

@@ -0,0 +1,49 @@
+import {DEFAULT_FORMATS, NUCLEOTIDES} from '../const';
+import {UNKNOWN_SYMBOL} from './const';
+import {FormatConverter} from './format-converter';
+import {codesToHelmDictionary} from '../data-loading-utils/json-loader';
+import {MonomerLibWrapper} from '../monomer-lib/lib-wrapper';
+
+export function getTranslatedSequences(sequence: string, indexOfFirstInvalidChar: number, sourceFormat: string): {[key: string]: string} {
+  const supportedFormats = Object.keys(codesToHelmDictionary).concat([DEFAULT_FORMATS.HELM]) as string[];
+
+  if (!sequence || (indexOfFirstInvalidChar !== -1 && sourceFormat !== DEFAULT_FORMATS.HELM))
+    return {};
+
+  if (!supportedFormats.includes(sourceFormat))
+    throw new Error(`${sourceFormat} format is not supported by SequenceTranslator`)
+
+  const outputFormats = supportedFormats.filter((el) => el != sourceFormat)
+    .sort((a, b) => a.localeCompare(b));
+  const converter = new FormatConverter(sequence, sourceFormat);
+  const result = Object.fromEntries(
+    outputFormats.map((format) => {
+      let translation;
+      try {
+        translation = converter.convertTo(format);
+      } catch {
+        translation = null;
+      }
+      return [format, translation];
+    }).filter(([format, translation]) => translation)
+  )
+  const helm = (sourceFormat === DEFAULT_FORMATS.HELM) ? sequence : result[DEFAULT_FORMATS.HELM];
+  const nucleotides = getNucleotidesSequence(helm, MonomerLibWrapper.getInstance());
+  if (nucleotides)
+    result['Nucleotides'] = nucleotides;
+  return result;
+}
+
+export function getNucleotidesSequence(helmString: string, monomerLib: MonomerLibWrapper): string | null {
+  const re = new RegExp('\\([^()]*\\)', 'g');
+  const branches = helmString.match(re);
+  if (!branches)
+    return null;
+  const nucleotides = branches!.map((branch) => {
+    const stripped = branch.replace(/[\[\]()]/g, '');
+    if (NUCLEOTIDES.includes(stripped))
+      return stripped;
+    return monomerLib.getNaturalAnalogBySymbol(stripped);
+  }).map((el) => el ? el : UNKNOWN_SYMBOL).join('');
+  return nucleotides;
+}

package/src/model/format-translation/format-converter.ts

@@ -0,0 +1,109 @@
+import * as DG from 'datagrok-api/dg';
+import {DEFAULT_FORMATS} from '../const';
+import {GROUP_TYPE, PHOSPHATE_SYMBOL, UNKNOWN_SYMBOL} from './const';
+import {CodesInfo} from '../data-loading-utils/types';
+import {codesToHelmDictionary} from '../data-loading-utils/json-loader';
+
+const HELM_WRAPPER = {
+  LEFT: 'RNA1{',
+  RIGHT: '}$$$$',
+};
+
+export class FormatConverter {
+  constructor(private readonly sequence: string, private readonly sourceFormat: string) { };
+
+  convertTo(targetFormat: string): string {
+    const formats = Object.keys(codesToHelmDictionary);
+
+    if (this.sourceFormat === DEFAULT_FORMATS.HELM && formats.includes(targetFormat))
+      return helmToFormat(this.sequence, targetFormat);
+    else if (formats.includes(this.sourceFormat) && targetFormat === DEFAULT_FORMATS.HELM)
+      return formatToHelm(this.sequence, this.sourceFormat);
+    else if ([this.sourceFormat, targetFormat].every((el) => formats.includes(el))) {
+      const helm = formatToHelm(this.sequence, this.sourceFormat);
+      return helmToFormat(helm, targetFormat);
+    }
+    else {
+      throw new Error (`ST: unsupported translation direction ${this.sourceFormat} -> ${targetFormat}`);
+    }
+  }
+}
+
+function getRegExpPattern(arr: string[]): string {
+  const negativeLookBehind = '(?<!\\([^()]*)'; // not '(' followed by non-parenths
+  const negativeLookAhead = '(?![^()]*\\))';  // not ')' preceded by non-parenths
+  const escaped = arr.map((key) => key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+    .map((key) => {
+    if (!key.includes('(') && !key.includes(')'))
+      return `${negativeLookBehind}${key}${negativeLookAhead}`;
+    return key;
+  });
+  const result =  escaped.join('|');
+  return result;
+}
+
+function sortCallback(a: string, b: string) {return b.length - a.length};
+
+function getHelmToCodeDict(infoObj: CodesInfo) {
+  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) {
+        result[key] = [code];
+      } else {
+        (result[key] as string[]).push(code);
+      }
+    })
+  });
+  Object.entries(result).forEach(([key, value]) => {
+    const sorted = (value as string[]).sort(sortCallback);
+    result[key] = sorted[0] as string;
+  })
+  return result as {[key: string]: string};
+}
+
+function helmToFormat(helmSequence: string, targetFormat: string): string {
+  const codesInfoObject = codesToHelmDictionary[targetFormat] as CodesInfo;
+  const dict = getHelmToCodeDict(codesInfoObject);
+  const wrapperRegExp = new RegExp(getRegExpPattern(Object.values(HELM_WRAPPER)), 'g')
+  let result = helmSequence.replace(wrapperRegExp, '');
+
+  const helmCodes = Object.keys(dict)
+    .sort(sortCallback);
+  const helmRegExp = new RegExp(getRegExpPattern(helmCodes) + '|.', 'g');
+  result = result.replace(helmRegExp, (match) => {
+    return helmCodes.includes(match) ? dict[match] :
+      (match === 'p' || match === '.') ? match : '?';
+  }).replace(/\?+/g, UNKNOWN_SYMBOL).replace(/p\.|\./g, '');
+  result = result.replace(/<empty>/g, '');
+  // remove double slash in LCMS codes
+  result = result.replace(/\/\//g, '/');
+  return result;
+}
+
+function formatToHelm(sequence: string, sourceFormat: string): string {
+  const codesInfoObject = codesToHelmDictionary[sourceFormat] as CodesInfo;
+  const dict = Object.assign({}, ...Object.values(codesInfoObject)) as {[code: string]: string};
+
+  const formatCodes = Object.keys(dict).sort(sortCallback);
+  const formatRegExp = new RegExp(getRegExpPattern(formatCodes) + '|\\([^()]*\\)|.', 'g'); // the added group before '|.' is to avoid mismatch inside parenths
+
+  const phosphateHELMCodes = Array.from(
+    new Set(Object.values(codesInfoObject[GROUP_TYPE.LINKAGE]))
+  ).sort(sortCallback);
+  const phosphateHELMPattern = getRegExpPattern(phosphateHELMCodes);
+  const phosphateRegExp = new RegExp(`${PHOSPHATE_SYMBOL}\.(${phosphateHELMPattern})`, 'g');
+
+  let helm = sequence.replace(formatRegExp, (match) => {
+    const result = formatCodes.includes(match) ?  dict[match] + '.' : '?';
+    return result;
+  });
+  helm = helm.replace(/\?+/g, `${UNKNOWN_SYMBOL}.`);
+  helm = helm.slice(0, -1); // strip last dot
+  if (helm[helm.length - 1] === PHOSPHATE_SYMBOL)
+    helm = helm.slice(0, -1);
+  helm = helm.replace(phosphateRegExp, (match, group) => group);
+  helm = helm.replace(/<empty>/g, '');
+  return `${HELM_WRAPPER.LEFT + helm + HELM_WRAPPER.RIGHT}`;
+}

package/src/model/helpers.ts

@@ -0,0 +1,12 @@
+import * as DG from 'datagrok-api/dg';
+
+export function sortByReverseLength(array: string[]): string[] {
+  return array.sort((a, b) => b.length - a.length);
+}
+
+export function download(name: string, href: string): void {
+  const element = document.createElement('a');
+  element.setAttribute('href', 'data:text/plain;charset=utf-8,' + href);
+  element.setAttribute('download', name);
+  element.click();
+}

package/src/model/monomer-lib/const.ts

@@ -0,0 +1,3 @@
+export const enum META_FIELDS {
+  MOLWEIGHT = 'molecularWeight',
+}

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

@@ -0,0 +1,119 @@
+/* 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 {_package} from '../../package';
+import {DEFAULT_FORMATS} from '../const';
+
+import {IMonomerLib, Monomer} from '@datagrok-libraries/bio/src/types';
+
+import {HELM_REQUIRED_FIELDS as REQ, HELM_OPTIONAL_FIELDS as OPT} from '@datagrok-libraries/bio/src/utils/const';
+import {META_FIELDS as MET} from './const';
+import {codesToSymbolsDictionary} from '../../model/data-loading-utils/json-loader';
+
+export class MonomerLibWrapper {
+  private constructor() {
+    const lib = _package.monomerLib;
+    if (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} = {};
+    formattedObject[REQ.NAME] = sourceObj[REQ.SYMBOL];
+    formattedObject[REQ.SYMBOL] = sourceObj[REQ.SYMBOL];
+    formattedObject[REQ.MOLFILE] = sourceObj[REQ.MOLFILE];
+    const formats = this.getAllFormats();
+    formats.forEach((format) => {
+      if (format === DEFAULT_FORMATS.HELM)
+        return;
+      const map = codesToSymbolsDictionary[format];
+      const codes = Object.keys(map).filter((code) => map[code] === sourceObj.symbol);
+      formattedObject[format] = codes.join(', ');
+    })
+
+    return formattedObject;
+  }
+
+  private getAllMonomers(): Monomer[] {
+    const polymerTypes = this.lib.getPolymerTypes();
+    let result: Monomer[] = [];
+    for (const polymerType of polymerTypes) {
+      const monomerSymbols = this.lib.getMonomerSymbolsByType(polymerType);
+      const monomersByType: Monomer[] = monomerSymbols
+        .map((monomerSymbol) => this.lib.getMonomer(polymerType, monomerSymbol))
+        .filter((monomer): monomer is Monomer => monomer !== null);
+      result = result.concat(monomersByType);
+    }
+    return result;
+  }
+
+  private getMonomer(monomerSymbol: string): Monomer {
+    const monomer = this.lib.getMonomer('RNA', monomerSymbol);
+    if (monomer === undefined)
+      throw new Error(`SequenceTranslator: no monomer with symbol ${monomerSymbol}`);
+    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;
+  }
+
+  getNaturalAnalogBySymbol(monomerSymbol: string): string {
+    const monomer = this.getMonomer(monomerSymbol);
+    const naturalAnalog = monomer.naturalAnalog;
+    if (!naturalAnalog)
+      throw new Error(`ST: no natural analog for ${monomerSymbol}`);
+    return naturalAnalog!;
+  }
+
+  // todo: a better criterion
+  isModification(monomerSymbol: string): boolean {
+    const molfile = this.getMolfileBySymbol(monomerSymbol);
+    return (molfile.includes('MODIFICATION')) ? true : false;
+  }
+
+  getCodeToSymbolMap(format: string): Map<string, string> {
+    return new Map<string, string>(Object.entries(codesToSymbolsDictionary[format]));
+  }
+
+  getCodesByFormat(format: string): string[] {
+    return Object.keys(codesToSymbolsDictionary[format]);
+  }
+
+  getAllFormats(): string[] {
+    return Object.keys(codesToSymbolsDictionary);
+  }
+
+  getTableForViewer(): DG.DataFrame {
+    const formattedObjects = this.allMonomers.map((monomer) => this.formatMonomerForViewer(monomer));
+    const df = DG.DataFrame.fromObjects(formattedObjects)!;
+    return df;
+  }
+
+  getCodesToWeightsMap(): Map<string, number> {
+    const codesToWeightsMap = new Map<string, number>();
+    Object.entries(codesToSymbolsDictionary).forEach(([_, dict]) => {
+      Object.entries(dict).forEach(([code, monomerSymbol]) => {
+        const monomer = this.getMonomer(monomerSymbol);
+        const weight = monomer[OPT.META]?.[MET.MOLWEIGHT];
+        codesToWeightsMap.set(code, weight);
+      });
+    });
+    return codesToWeightsMap;
+  }
+}

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

@@ -0,0 +1,57 @@
+/* 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 {sortByReverseLength} from '../helpers';
+import {DEFAULT_FORMATS} from '../const';
+import {MonomerLibWrapper} from '../monomer-lib/lib-wrapper';
+import {codesToHelmDictionary} from '../data-loading-utils/json-loader';
+import {SequenceValidator} from './sequence-validator';
+
+export class FormatDetector {
+  constructor (private sequence: string) {
+    this.libWrapper = MonomerLibWrapper.getInstance();
+    this.formats = Object.keys(codesToHelmDictionary);
+  };
+
+  private libWrapper: MonomerLibWrapper;
+  private formats: string[];
+
+  getFormat(): string | null {
+    // todo: reliable criterion
+    if (this.sequence.startsWith('RNA'))
+      return DEFAULT_FORMATS.HELM;
+    const possibleFormats = this.getListOfPossibleSynthesizersByFirstMatchedCode();
+    if (possibleFormats.length === 0)
+      return null;
+
+    const validator = new SequenceValidator(this.sequence);
+    const outputIndices = Array(possibleFormats.length).fill(0);
+    for (let i = 0; i < possibleFormats.length; ++i) {
+      const format = possibleFormats[i];
+      outputIndices[i] = validator.getInvalidCodeIndex(format);
+    }
+    const formatIdx = (outputIndices.some((idx) => idx === -1)) ? -1 : Math.max(...outputIndices);
+    return possibleFormats[outputIndices.indexOf(formatIdx)];
+  }
+
+  // todo: rename
+  private getListOfPossibleSynthesizersByFirstMatchedCode(): string[] {
+    const sequence = this.sequence;
+    let synthesizers: string[] = [];
+    for (const format of this.formats) {
+      let codes = sortByReverseLength(this.libWrapper.getCodesByFormat(format));
+      let start = 0;
+      for (let i = 0; i < sequence.length; i++) {
+        if (sequence[i] === ')' && i !== sequence.length - 1) {
+          start = i + 1;
+          break;
+        }
+      }
+      if (codes.some((s: string) => s === sequence.slice(start, start + s.length)))
+        synthesizers.push(format);
+    }
+    return synthesizers;
+  }
+}