@datagrok/sequence-translator 1.0.12 → 1.0.14

package/src/main/main-view.ts

@@ -2,20 +2,35 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 import {convertSequence, undefinedInputSequence, isValidSequence} from '../structures-works/sequence-codes-tools';
-import {map, MODIFICATIONS} from '../structures-works/map';
+import {map} from '../structures-works/map';
+import {MODIFICATIONS} from '../structures-works/const';
 import {sequenceToSmiles, sequenceToMolV3000} from '../structures-works/from-monomers';
 import $ from 'cash-dom';
+import {download} from '../helpers';
 
-const defaultInput = 'fAmCmGmAmCpsmU';
-const sequenceWasCopied = 'Copied';
+const defaultInput = 'fAmCmGmAmCpsmU'; // todo: capitalize constants
+const sequenceWasCopied = 'Copied'; // todo: wrap hardcoded literals into constants
 const tooltipSequence = 'Copy sequence';
 
-export function mainView() {
-  function updateTableAndMolecule(sequence: string, inputFormat: string): void {
+export async function mainView(): Promise<HTMLDivElement> {
+  const monomersLibAddress = 'System:AppData/SequenceTranslator/helmLib.json';
+  async function updateTableAndMolecule(sequence: string, inputFormat: string): Promise<void> {
     moleculeSvgDiv.innerHTML = '';
     outputTableDiv.innerHTML = '';
     const pi = DG.TaskBarProgressIndicator.create('Rendering table and molecule...');
     let errorsExist = false;
+
+    // external helm-like monomers library
+    const fileExists = await grok.dapi.files.exists(monomersLibAddress);
+    if (!fileExists) {
+      // todo: improve behaviour in this case
+      grok.shell.warning('Please, provide the file with monomers library as System:AppData/SequenceTranslator/helmLib.json');
+      pi.close();
+      return;
+    }
+
+    const monomersLib = await grok.dapi.files.readAsText(monomersLibAddress);
+
     try {
       sequence = sequence.replace(/\s/g, '');
       const output = isValidSequence(sequence, null);
@@ -27,42 +42,21 @@ export function mainView() {
         const indexOfFirstNotValidChar = ('indexOfFirstNotValidChar' in outputSequenceObj) ?
           JSON.parse(outputSequenceObj.indexOfFirstNotValidChar!).indexOfFirstNotValidChar :
           -1;
-        if ('indexOfFirstNotValidChar' in outputSequenceObj) {
-          const indexOfFirstNotValidChar = ('indexOfFirstNotValidChar' in outputSequenceObj) ?
-            JSON.parse(outputSequenceObj.indexOfFirstNotValidChar!).indexOfFirstNotValidChar :
-            -1;
-          if (indexOfFirstNotValidChar != -1)
-            errorsExist = true;
-        }
 
         tableRows.push({
           'key': key,
           'value': ('indexOfFirstNotValidChar' in outputSequenceObj) ?
-            ui.divH([
-              ui.divText(sequence.slice(0, indexOfFirstNotValidChar), {style: {color: 'grey'}}),
-              ui.tooltip.bind(
-                ui.divText(sequence.slice(indexOfFirstNotValidChar), {style: {color: 'red'}}),
-                'Expected format: ' + JSON.parse(outputSequenceObj.indexOfFirstNotValidChar!).synthesizer +
-                '. See tables with valid codes on the right',
-              ),
-            ]) : //@ts-ignore
-            ui.link(outputSequenceObj[key], () => navigator.clipboard.writeText(outputSequenceObj[key])
-              .then(() => grok.shell.info(sequenceWasCopied)), tooltipSequence, ''),
-        });
-      }
-
-      if (errorsExist) {
-        const synthesizer = JSON.parse(outputSequenceObj.indexOfFirstNotValidChar!).synthesizer.slice(0, -6);
-        asoGapmersGrid.onCellPrepare(function(gc) {
-          gc.style.backColor = (gc.gridColumn.name == synthesizer) ? 0xFFF00000 : 0xFFFFFFFF;
-        });
-        omeAndFluoroGrid.onCellPrepare(function(gc) {
-          gc.style.backColor = (gc.gridColumn.name == synthesizer) ? 0xFFF00000 : 0xFFFFFFFF;
+          ui.divH([
+            ui.divText(sequence.slice(0, indexOfFirstNotValidChar), {style: {color: 'grey'}}),
+            ui.tooltip.bind(
+              ui.divText(sequence.slice(indexOfFirstNotValidChar), {style: {color: 'red'}}),
+              'Expected format: ' + JSON.parse(outputSequenceObj.indexOfFirstNotValidChar!).synthesizer +
+              '. See tables with valid codes on the right',
+            ),
+          ]) : //@ts-ignore
+          ui.link(outputSequenceObj[key], () => navigator.clipboard.writeText(outputSequenceObj[key])
+            .then(() => grok.shell.info(sequenceWasCopied)), tooltipSequence, ''),
         });
-        switchInput.enabled = true;
-      } else {
-        asoGapmersGrid.onCellPrepare(function(gc) {gc.style.backColor = 0xFFFFFFFF;});
-        omeAndFluoroGrid.onCellPrepare(function(gc) {gc.style.backColor = 0xFFFFFFFF;});
       }
 
       outputTableDiv.append(
@@ -76,8 +70,11 @@ export function mainView() {
         const canvas = ui.canvas(300, 170);
         canvas.addEventListener('click', () => {
           const canv = ui.canvas($(window).width(), $(window).height());
-          const mol = sequenceToMolV3000(inputSequenceField.value.replace(/\s/g, ''), false, true,
-            output.synthesizer![0]);
+          const mol = sequenceToMolV3000(
+            inputSequenceField.value.replace(/\s/g, ''), false, true,
+            output.synthesizer![0],
+          );
+          console.log(mol);
           // @ts-ignore
           OCL.StructureView.drawMolecule(canv, OCL.Molecule.fromMolfile(mol), {suppressChiralText: true});
           ui.dialog('Molecule: ' + inputSequenceField.value)
@@ -87,7 +84,7 @@ export function mainView() {
         $(canvas).on('mouseover', () => $(canvas).css('cursor', 'zoom-in'));
         $(canvas).on('mouseout', () => $(canvas).css('cursor', 'default'));
         const mol = sequenceToMolV3000(inputSequenceField.value.replace(/\s/g, ''), false, true,
-        output.synthesizer![0]);
+          output.synthesizer![0]);
         // @ts-ignore
         OCL.StructureView.drawMolecule(canvas, OCL.Molecule.fromMolfile(mol), {suppressChiralText: true});
         moleculeSvgDiv.append(canvas);
@@ -108,46 +105,43 @@ export function mainView() {
     updateTableAndMolecule(sequence, inputFormatChoiceInput.value!);
   });
 
-  const asoDf = DG.DataFrame.fromObjects([
-    {'Name': '2\'MOE-5Me-rU', 'BioSpring': '5', 'Janssen GCRS': 'moeT'},
-    {'Name': '2\'MOE-rA', 'BioSpring': '6', 'Janssen GCRS': 'moeA'},
-    {'Name': '2\'MOE-5Me-rC', 'BioSpring': '7', 'Janssen GCRS': 'moe5mC'},
-    {'Name': '2\'MOE-rG', 'BioSpring': '8', 'Janssen GCRS': 'moeG'},
-    {'Name': '5-Methyl-dC', 'BioSpring': '9', 'Janssen GCRS': '5mC'},
-    {'Name': 'ps linkage', 'BioSpring': '*', 'Janssen GCRS': 'ps'},
-    {'Name': 'dA', 'BioSpring': 'A', 'Janssen GCRS': 'A, dA'},
-    {'Name': 'dC', 'BioSpring': 'C', 'Janssen GCRS': 'C, dC'},
-    {'Name': 'dG', 'BioSpring': 'G', 'Janssen GCRS': 'G, dG'},
-    {'Name': 'dT', 'BioSpring': 'T', 'Janssen GCRS': 'T, dT'},
-    {'Name': 'rA', 'BioSpring': '', 'Janssen GCRS': 'rA'},
-    {'Name': 'rC', 'BioSpring': '', 'Janssen GCRS': 'rC'},
-    {'Name': 'rG', 'BioSpring': '', 'Janssen GCRS': 'rG'},
-    {'Name': 'rU', 'BioSpring': '', 'Janssen GCRS': 'rU'},
-  ])!;
-  const asoGapmersGrid = DG.Viewer.grid(asoDf, {showRowHeader: false, showCellTooltip: false});
-
-  asoDf.onCurrentCellChanged.subscribe((_) => {
-    navigator.clipboard.writeText(asoDf.currentCell.value).then(() => grok.shell.info('Copied'));
-  });
+  const asoGapmersGrid = DG.Viewer.grid(
+    DG.DataFrame.fromObjects([
+      {'Name': '2\'MOE-5Me-rU', 'BioSpring': '5', 'Janssen GCRS': 'moeT'},
+      {'Name': '2\'MOE-rA', 'BioSpring': '6', 'Janssen GCRS': 'moeA'},
+      {'Name': '2\'MOE-5Me-rC', 'BioSpring': '7', 'Janssen GCRS': 'moe5mC'},
+      {'Name': '2\'MOE-rG', 'BioSpring': '8', 'Janssen GCRS': 'moeG'},
+      {'Name': '5-Methyl-dC', 'BioSpring': '9', 'Janssen GCRS': '5mC'},
+      {'Name': 'ps linkage', 'BioSpring': '*', 'Janssen GCRS': 'ps'},
+      {'Name': 'dA', 'BioSpring': 'A', 'Janssen GCRS': 'A, dA'},
+      {'Name': 'dC', 'BioSpring': 'C', 'Janssen GCRS': 'C, dC'},
+      {'Name': 'dG', 'BioSpring': 'G', 'Janssen GCRS': 'G, dG'},
+      {'Name': 'dT', 'BioSpring': 'T', 'Janssen GCRS': 'T, dT'},
+      {'Name': 'rA', 'BioSpring': '', 'Janssen GCRS': 'rA'},
+      {'Name': 'rC', 'BioSpring': '', 'Janssen GCRS': 'rC'},
+      {'Name': 'rG', 'BioSpring': '', 'Janssen GCRS': 'rG'},
+      {'Name': 'rU', 'BioSpring': '', 'Janssen GCRS': 'rU'},
+    ])!, {showRowHeader: false, showCellTooltip: false, allowEdit: false},
+  );
 
   const omeAndFluoroGrid = DG.Viewer.grid(
-      DG.DataFrame.fromObjects([
-        {'Name': '2\'-fluoro-U', 'BioSpring': '1', 'Axolabs': 'Uf', 'Janssen GCRS': 'fU'},
-        {'Name': '2\'-fluoro-A', 'BioSpring': '2', 'Axolabs': 'Af', 'Janssen GCRS': 'fA'},
-        {'Name': '2\'-fluoro-C', 'BioSpring': '3', 'Axolabs': 'Cf', 'Janssen GCRS': 'fC'},
-        {'Name': '2\'-fluoro-G', 'BioSpring': '4', 'Axolabs': 'Gf', 'Janssen GCRS': 'fG'},
-        {'Name': '2\'OMe-rU', 'BioSpring': '5', 'Axolabs': 'u', 'Janssen GCRS': 'mU'},
-        {'Name': '2\'OMe-rA', 'BioSpring': '6', 'Axolabs': 'a', 'Janssen GCRS': 'mA'},
-        {'Name': '2\'OMe-rC', 'BioSpring': '7', 'Axolabs': 'c', 'Janssen GCRS': 'mC'},
-        {'Name': '2\'OMe-rG', 'BioSpring': '8', 'Axolabs': 'g', 'Janssen GCRS': 'mG'},
-        {'Name': 'ps linkage', 'BioSpring': '*', 'Axolabs': 's', 'Janssen GCRS': 'ps'},
-      ])!, {showRowHeader: false, showCellTooltip: false},
+    DG.DataFrame.fromObjects([
+      {'Name': '2\'-fluoro-U', 'BioSpring': '1', 'Axolabs': 'Uf', 'Janssen GCRS': 'fU'},
+      {'Name': '2\'-fluoro-A', 'BioSpring': '2', 'Axolabs': 'Af', 'Janssen GCRS': 'fA'},
+      {'Name': '2\'-fluoro-C', 'BioSpring': '3', 'Axolabs': 'Cf', 'Janssen GCRS': 'fC'},
+      {'Name': '2\'-fluoro-G', 'BioSpring': '4', 'Axolabs': 'Gf', 'Janssen GCRS': 'fG'},
+      {'Name': '2\'OMe-rU', 'BioSpring': '5', 'Axolabs': 'u', 'Janssen GCRS': 'mU'},
+      {'Name': '2\'OMe-rA', 'BioSpring': '6', 'Axolabs': 'a', 'Janssen GCRS': 'mA'},
+      {'Name': '2\'OMe-rC', 'BioSpring': '7', 'Axolabs': 'c', 'Janssen GCRS': 'mC'},
+      {'Name': '2\'OMe-rG', 'BioSpring': '8', 'Axolabs': 'g', 'Janssen GCRS': 'mG'},
+      {'Name': 'ps linkage', 'BioSpring': '*', 'Axolabs': 's', 'Janssen GCRS': 'ps'},
+    ])!, {showRowHeader: false, showCellTooltip: false, allowEdit: false},
   );
 
   const overhangModificationsGrid = DG.Viewer.grid(
       DG.DataFrame.fromColumns([
         DG.Column.fromStrings('Name', Object.keys(MODIFICATIONS)),
-      ])!, {showRowHeader: false, showCellTooltip: false},
+      ])!, {showRowHeader: false, showCellTooltip: false, allowEdit: false},
   );
   updateTableAndMolecule(defaultInput, inputFormatChoiceInput.value!);
 
@@ -175,27 +169,31 @@ export function mainView() {
     $(codesTablesDiv).hide(),
   );
 
+  const downloadMolFileIcon = ui.iconFA('download', async () => {
+    const clearSequence = inputSequenceField.value.replace(/\s/g, '');
+    const monomersLib = await grok.dapi.files.readAsText(monomersLibAddress);
+    const result = sequenceToMolV3000(inputSequenceField.value.replace(/\s/g, ''), false, false,
+      inputFormatChoiceInput.value!);
+    download(clearSequence + '.mol', encodeURIComponent(result));
+  }, 'Save .mol file');
+
+  const copySmilesIcon = ui.iconFA('copy', () => {
+    navigator.clipboard.writeText(
+      sequenceToSmiles(inputSequenceField.value.replace(/\s/g, ''), false, inputFormatChoiceInput.value!),
+    ).then(() => grok.shell.info(sequenceWasCopied));
+  }, 'Copy SMILES');
+
   const topPanel = [
-    ui.iconFA('download', () => {
-      const result = sequenceToMolV3000(inputSequenceField.value.replace(/\s/g, ''), false, false,
-        inputFormatChoiceInput.value!);
-      const element = document.createElement('a');
-      element.setAttribute('href', 'data:text/plain;charset=utf-8,' + encodeURIComponent(result));
-      element.setAttribute('download', inputSequenceField.value.replace(/\s/g, '') + '.mol');
-      element.click();
-    }, 'Save .mol file'),
-    ui.iconFA('copy', () => {
-      navigator.clipboard.writeText(
-        sequenceToSmiles(inputSequenceField.value.replace(/\s/g, ''), false, inputFormatChoiceInput.value!))
-        .then(() => grok.shell.info(sequenceWasCopied));
-    }, 'Copy SMILES'),
+    downloadMolFileIcon,
+    copySmilesIcon,
     switchInput.root,
   ];
 
   const v = grok.shell.v;
   const tabControl = grok.shell.sidebar;
-  tabControl.onTabChanged.subscribe((_) =>
-    v.setRibbonPanels([(tabControl.currentPane.name == 'MAIN') ? topPanel : []]));
+  tabControl.onTabChanged.subscribe((_) => {
+    v.setRibbonPanels([(tabControl.currentPane.name == 'MAIN') ? topPanel : []]);
+  });
   v.setRibbonPanels([topPanel]);
 
   return ui.box(

package/src/package.ts

@@ -5,26 +5,43 @@ import {autostartOligoSdFileSubscription} from './autostart/registration';
 import {defineAxolabsPattern} from './axolabs/define-pattern';
 import {saveSenseAntiSense} from './structures-works/save-sense-antisense';
 import {mainView} from './main/main-view';
+import {IMonomerLib, MonomerWorks, readLibrary} from '@datagrok-libraries/bio';
 
 export const _package = new DG.Package();
 
+const LIB_PATH = 'System:AppData/SequenceTranslator';
+
+let monomerLib: IMonomerLib | null = null;
+export let monomerWorks: MonomerWorks | null = null;
+
+export function getMonomerWorks() {
+  return monomerWorks;
+};
+
+export function getMonomerLib() {
+  return monomerLib;
+};
 
 //name: Sequence Translator
 //tags: app
-export function sequenceTranslator(): void {
+export async function sequenceTranslator(): Promise<void> {
+  monomerLib = await readLibrary(LIB_PATH, 'helmLib.json');
+
+  if (monomerWorks == null)
+    monomerWorks = new MonomerWorks(monomerLib);
+
   const windows = grok.shell.windows;
   windows.showProperties = false;
   windows.showToolbox = false;
   windows.showHelp = false;
 
-  const v = grok.shell.newView('Sequence Translator', [
-    ui.tabControl({
-      'MAIN': mainView(),
-      'AXOLABS': defineAxolabsPattern(),
-      'SDF': saveSenseAntiSense(),
-    }),
-  ]);
+  const v = grok.shell.newView('Sequence Translator', []);
   v.box = true;
+  v.append(ui.tabControl({
+    'MAIN': await mainView(),
+    'AXOLABS': defineAxolabsPattern(),
+    'SDF': saveSenseAntiSense(),
+  }));
 }
 
 //tags: autostart

package/src/structures-works/const.ts

@@ -0,0 +1,18 @@
+export const MODIFICATIONS: {[index: string]: {molecularWeight: number, left: string, right: string}} = {
+  '(invabasic)': {
+    molecularWeight: 118.13,
+    left: 'O[C@@H]1C[C@@H]O[C@H]1CO',
+    right: 'O[C@@H]1C[C@@H]O[C@H]1CO',
+  },
+  '(GalNAc-2-JNJ)': {
+    molecularWeight: 1273.3,
+    left: 'C(COCCC(=O)NCCCNC(=O)CCCCOC2OC(CO)C(O)C(O)C2NC(=O)C)' +
+    '(COCCC(=O)NCCCNC(=O)CCCCOC2OC(CO)C(O)C(O)C2NC(=O)C)' +
+    '(COCCC(=O)NCCCNC(=O)CCCCOC2OC(CO)C(O)C(O)C2NC(=O)C)NC(=O)CCCC(=O)NCC(O)CO',
+    right: 'OCC(O)CNC(=O)CCCC(=O)NC(COCCC(=O)NCCCNC(=O)CCCCOC2OC(CO)C(O)C(O)C2NC(=O)C)' +
+    '(COCCC(=O)NCCCNC(=O)CCCCOC2OC(CO)C(O)C(O)C2NC(=O)C)'+
+    '(COCCC(=O)NCCCNC(=O)CCCCOC2OC(CO)C(O)C(O)C2NC(=O)C)',
+  },
+};
+
+export const standardPhosphateLinkSmiles = 'OP(=O)(O)O';

package/src/structures-works/converters.ts

@@ -1,6 +1,6 @@
 import {lcmsToGcrs} from './map';
 import * as DG from 'datagrok-api/dg';
-import {delimiter} from './map';
+import {DELIMITER} from './map';
 //name: gcrsToLcms
 //input: string nucleotides {semType: GCRS}
 //output: string result {semType: LCMS}
@@ -10,14 +10,14 @@ export function gcrsToLcms(sequence: string): string {
   const arr2 = df.getCol('LCMS').toList();
   const obj: {[i: string]: string} = {};
   arr1.forEach((element, index) => obj[element] = arr2[index]);
-  obj[delimiter] = delimiter;
+  obj[DELIMITER] = DELIMITER;
   // for (let i = 0; i < arr1.length; i++) {
   //   arr1[i] = arr1[i].replace('(', '\\(');
   //   arr1[i] = arr1[i].replace(')', '\\)');
   // }
   // const regExp = new RegExp('(' + arr1.join('|') + ')', 'g');
   // let r1 = sequence.replace(regExp, function(code) {return obj[code];});
-  const codes = arr1.concat(delimiter).sort(function(a, b) {return b.length - a.length;});
+  const codes = arr1.concat(DELIMITER).sort(function(a, b) {return b.length - a.length;});
   let i = 0;
   let r1 = '';
   while (i < sequence.length) {

package/src/structures-works/from-monomers.ts

@@ -1,43 +1,104 @@
-import {map, stadardPhosphateLinkSmiles, SYNTHESIZERS, TECHNOLOGIES, MODIFICATIONS, delimiter} from './map';
+// import {map, SYNTHESIZERS, TECHNOLOGIES, MODIFICATIONS, DELIMITER} from './map';
+import {map, SYNTHESIZERS, TECHNOLOGIES, DELIMITER} from './map';
 import {isValidSequence} from './sequence-codes-tools';
+import {sortByStringLengthInDescendingOrder} from '../helpers';
+import {getMonomerWorks} from '../package';
 import {getNucleotidesMol} from './mol-transformations';
 
-export function sequenceToMolV3000(sequence: string, inverted: boolean = false, oclRender: boolean = false,
-  format: string): string {
-  const obj = getObjectWithCodesAndSmiles(sequence, format);
-  let codes = sortByStringLengthInDescendingOrder(Object.keys(obj));
+import {standardPhosphateLinkSmiles, MODIFICATIONS} from './const';
+import {getMonomerLib} from '../package';
+// todo: remove
+// const NAME = 'name';
+const CODES = 'codes';
+// const SMILES = 'smiles';
+const MOL = 'molfile';
+
+export function sequenceToMolV3000(
+  sequence: string, inverted: boolean = false, oclRender: boolean = false,
+  format: string,
+): string {
+  const monomerNameFromCode = getCodeToNameMap(sequence, format);
+  let codes = sortByStringLengthInDescendingOrder(Object.keys(monomerNameFromCode));
   let i = 0;
-  const smilesCodes:string[] = [];
   const codesList = [];
   const links = ['s', 'ps', '*'];
   const includesStandardLinkAlready = ['e', 'h', /*'g',*/ 'f', 'i', 'l', 'k', 'j'];
   const dropdowns = Object.keys(MODIFICATIONS);
-  codes = codes.concat(dropdowns).concat(delimiter);
+  codes = codes.concat(dropdowns).concat(DELIMITER);
   while (i < sequence.length) {
-    const code = codes.find((s: string) => s == sequence.slice(i, i + s.length))!;
+    const code = codes.find((s: string) => s === sequence.slice(i, i + s.length))!;
     i += code.length;
     inverted ? codesList.unshift(code) : codesList.push(code);
   }
+
+  const monomers: string[] = [];
+
   for (let i = 0; i < codesList.length; i++) {
-    if (dropdowns.includes(codesList[i])) {
-      smilesCodes.push((i >= codesList.length / 2) ?
-        MODIFICATIONS[codesList[i]].right : MODIFICATIONS[codesList[i]].left);
-      if (!(i < codesList.length - 1 && links.includes(codesList[i + 1])))
-        smilesCodes.push(stadardPhosphateLinkSmiles);
-    } else {
-      if (links.includes(codesList[i]) ||
-        includesStandardLinkAlready.includes(codesList[i]) ||
-        (i < codesList.length - 1 && links.includes(codesList[i + 1]))
-      )
-        smilesCodes.push(obj[codesList[i]]);
-      else {
-        smilesCodes.push(obj[codesList[i]]);
-        smilesCodes.push(stadardPhosphateLinkSmiles);
-      }
+    if (links.includes(codesList[i]) ||
+      includesStandardLinkAlready.includes(codesList[i]) ||
+      (i < codesList.length - 1 && links.includes(codesList[i + 1]))
+    ) {
+      let aa = monomerNameFromCode[codesList[i]];
+      if(aa !== undefined)
+        monomers.push(aa);
+      else
+        monomers.push(codesList[i]);
+    }
+    else {
+      let aa = monomerNameFromCode[codesList[i]];
+      if(aa !== undefined)
+      monomers.push(aa);
+    else
+      monomers.push(codesList[i]);
+      monomers.push('p linkage');
+    }
+  }
+
+  const lib = getMonomerLib();
+  const mols: string [] = [];
+  for(let i = 0; i < monomers.length; i++) {
+    const mnmr = lib?.getMonomer('RNA', monomers[i]);
+    mols.push(mnmr?.molfile!);
+  }
+
+
+  return getNucleotidesMol(mols);
+  //return getMonomerWorks()?.getAtomicLevel(monomers, 'RNA')!;
+}
+
+export function sequenceToMolV3000_new(
+  sequence: string, inverted: boolean = false, oclRender: boolean = false,
+  format: string,
+): string {
+  const monomerNameFromCode = getCodeToNameMap(sequence, format);
+  let codes = sortByStringLengthInDescendingOrder(Object.keys(monomerNameFromCode));
+  let i = 0;
+  const codesList = [];
+  const links = ['s', 'ps', '*'];
+  const includesStandardLinkAlready = ['e', 'h', /*'g',*/ 'f', 'i', 'l', 'k', 'j'];
+  const dropdowns = Object.keys(MODIFICATIONS);
+  codes = codes.concat(dropdowns).concat(DELIMITER);
+  while (i < sequence.length) {
+    const code = codes.find((s: string) => s === sequence.slice(i, i + s.length))!;
+    i += code.length;
+    inverted ? codesList.unshift(code) : codesList.push(code);
+  }
+
+  const monomers: string[] = [];
+
+  for (let i = 0; i < codesList.length; i++) {
+    if (links.includes(codesList[i]) ||
+      includesStandardLinkAlready.includes(codesList[i]) ||
+      (i < codesList.length - 1 && links.includes(codesList[i + 1]))
+    )
+      monomers.push(monomerNameFromCode[codesList[i]]);
+    else {
+      monomers.push(monomerNameFromCode[codesList[i]]);
+      monomers.push('p linkage');
     }
   }
 
-  return getNucleotidesMol(smilesCodes);
+  return getMonomerWorks()?.getAtomicLevel(monomers, 'RNA')!;
 }
 
 export function sequenceToSmiles(sequence: string, inverted: boolean = false, format: string): string {
@@ -49,7 +110,7 @@ export function sequenceToSmiles(sequence: string, inverted: boolean = false, fo
   const links = ['s', 'ps', '*'];
   const includesStandardLinkAlready = ['e', 'h', /*'g',*/ 'f', 'i', 'l', 'k', 'j'];
   const dropdowns = Object.keys(MODIFICATIONS);
-  codes = codes.concat(dropdowns).concat(delimiter);
+  codes = codes.concat(dropdowns).concat(DELIMITER);
   while (i < sequence.length) {
     const code = codes.find((s: string) => s == sequence.slice(i, i + s.length))!;
     i += code.length;
@@ -58,8 +119,8 @@ export function sequenceToSmiles(sequence: string, inverted: boolean = false, fo
   for (let i = 0; i < codesList.length; i++) {
     if (dropdowns.includes(codesList[i])) {
       smiles += (i >= codesList.length / 2) ?
-        MODIFICATIONS[codesList[i]].right + stadardPhosphateLinkSmiles:
-        MODIFICATIONS[codesList[i]].left + stadardPhosphateLinkSmiles;
+        MODIFICATIONS[codesList[i]].right + standardPhosphateLinkSmiles :
+        MODIFICATIONS[codesList[i]].left + standardPhosphateLinkSmiles;
     } else {
       if (links.includes(codesList[i]) ||
         includesStandardLinkAlready.includes(codesList[i]) ||
@@ -67,7 +128,7 @@ export function sequenceToSmiles(sequence: string, inverted: boolean = false, fo
       )
         smiles += obj[codesList[i]];
       else
-        smiles += obj[codesList[i]] + stadardPhosphateLinkSmiles;
+        smiles += obj[codesList[i]] + standardPhosphateLinkSmiles;
     }
   }
   smiles = smiles.replace(/OO/g, 'O');
@@ -81,7 +142,34 @@ export function sequenceToSmiles(sequence: string, inverted: boolean = false, fo
     includesStandardLinkAlready.includes(codesList[codesList.length - 1])
   ) ?
     smiles :
-    smiles.slice(0, smiles.length - stadardPhosphateLinkSmiles.length + 1);
+    smiles.slice(0, smiles.length - standardPhosphateLinkSmiles.length + 1);
+}
+
+function getCodeToNameMap(sequence: string, format: string) {
+  const obj: { [code: string]: string } = {};
+  const NAME = 'name';
+  if (format == null) {
+    for (const synthesizer of Object.keys(map)) {
+      for (const technology of Object.keys(map[synthesizer])) {
+        for (const code of Object.keys(map[synthesizer][technology]))
+          obj[code] = map[synthesizer][technology][code][NAME]!;
+      }
+    }
+  } else {
+    for (const technology of Object.keys(map[format])) {
+      for (const code of Object.keys(map[format][technology]))
+        obj[code] = map[format][technology][code][NAME]!;
+      // obj[code] = map[format][technology][code].SMILES;
+    }
+  }
+  obj[DELIMITER] = '';
+  // TODO: create object based from synthesizer type to avoid key(codes) duplicates
+  const output = isValidSequence(sequence, format);
+  if (output.synthesizer!.includes(SYNTHESIZERS.MERMADE_12))
+    obj['g'] = map[SYNTHESIZERS.MERMADE_12][TECHNOLOGIES.SI_RNA]['g'][NAME]!;
+  else if (output.synthesizer!.includes(SYNTHESIZERS.AXOLABS))
+    obj['g'] = map[SYNTHESIZERS.AXOLABS][TECHNOLOGIES.SI_RNA]['g'][NAME]!;
+  return obj;
 }
 
 function getObjectWithCodesAndSmiles(sequence: string, format: string) {
@@ -99,7 +187,7 @@ function getObjectWithCodesAndSmiles(sequence: string, format: string) {
         obj[code] = map[format][technology][code].SMILES;
     }
   }
-  obj[delimiter] = '';
+  obj[DELIMITER] = '';
   // TODO: create object based from synthesizer type to avoid key(codes) duplicates
   const output = isValidSequence(sequence, format);
   if (output.synthesizer!.includes(SYNTHESIZERS.MERMADE_12))
@@ -109,6 +197,71 @@ function getObjectWithCodesAndSmiles(sequence: string, format: string) {
   return obj;
 }
 
-function sortByStringLengthInDescendingOrder(array: string[]): string[] {
-  return array.sort(function(a: string, b: string) {return b.length - a.length;});
+function getObjectWithCodesAndMolsFromFile(sequence: string, format: string, libFileContent: string) {
+  const obj: { [code: string]: string } = {};
+  // todo: type
+  const lib: any[] = JSON.parse(libFileContent); //consider using library
+
+  for (const item of lib) {
+    for (const synthesizer of Object.keys(item[CODES])) {
+      if (synthesizer === format) {
+        for (const technology of Object.keys(item[CODES][synthesizer])) {
+          const codes = item[CODES][synthesizer][technology];
+          let mol: string = item[MOL];
+          // todo: find another solution
+          mol = mol.replace(/ R /g, ' O ');
+
+          for (const code of codes)
+            obj[code] = mol;
+        }
+      }
+    }
+  }
+
+  obj[DELIMITER] = '';
+  // TODO: create object based on synthesizer type to avoid key(codes) duplicates
+  const output = isValidSequence(sequence, format);
+  if (output.synthesizer!.includes(SYNTHESIZERS.MERMADE_12)) {
+    // todo: remove as quickfix, optimize access to 'g'
+    for (const item of lib) {
+      for (const synthesizer of Object.keys(item[CODES])) {
+        for (const technology of Object.keys(item[CODES][synthesizer])) {
+          const codes = item[CODES][synthesizer][technology];
+          for (const code of codes) {
+            const condition =
+              (code === 'g') &&
+              (synthesizer === SYNTHESIZERS.MERMADE_12) &&
+              (technology === TECHNOLOGIES.SI_RNA);
+            if (condition) {
+              let mol: string = item[MOL];
+              // todo: find another solution
+              mol = mol.replace(/ R /g, ' O ');
+              obj[code] = mol;
+            }
+          }
+        }
+      }
+    }
+  } else if (output.synthesizer!.includes(SYNTHESIZERS.AXOLABS)) {
+    for (const item of lib) {
+      for (const synthesizer of Object.keys(item[CODES])) {
+        for (const technology of Object.keys(item[CODES][synthesizer])) {
+          const codes = item[CODES][synthesizer][technology];
+          for (const code of codes) {
+            const condition =
+              (code === 'g') &&
+              (synthesizer === SYNTHESIZERS.AXOLABS) &&
+              (technology === TECHNOLOGIES.SI_RNA);
+            if (condition) {
+              let mol: string = item[MOL];
+              // todo: find another solution
+              mol = mol.replace(/ R /g, ' O ');
+              obj[code] = mol;
+            }
+          }
+        }
+      }
+    }
+  }
+  return obj;
 }