@datagrok/sequence-translator 1.0.17 → 1.1.4

package/src/model/sequence-to-structure-utils/sequence-to-molfile.ts

@@ -0,0 +1,409 @@
+/* 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 {MonomerSequenceParser} from './monomer-code-parser';
+import {MonomerLibWrapper} from '../monomer-lib/lib-wrapper';
+
+export class SequenceToMolfileConverter {
+  constructor(
+    sequence: string, invert: boolean = false, format: string
+  ) {
+    this.lib = MonomerLibWrapper.getInstance();
+    const codeToSymbolMap = this.lib.getCodeToSymbolMap(format);
+    this.parser = new MonomerSequenceParser(sequence, invert, codeToSymbolMap);
+  }
+
+  private parser: MonomerSequenceParser;
+  private lib: MonomerLibWrapper;
+
+  convert(): string {
+    const parsedSequence = this.parser.parseSequence();
+    const monomerMolfiles: string[] = [];
+    parsedSequence.forEach((monomerSymbol, idx) => {
+      const monomerMolfile = this.getMonomerMolfile(monomerSymbol, idx);
+      monomerMolfiles.push(monomerMolfile);
+    })
+    return this.getPolymerMolfile(monomerMolfiles);
+  }
+
+  private getMonomerMolfile(monomerSymbol: string, idx: number): string {
+    const molBlock = this.lib.getMolfileBySymbol(monomerSymbol);
+    if (this.lib.isModification(monomerSymbol))
+      return (idx === 0) ? this.reflect(molBlock) : molBlock;
+    else
+      return this.rotateNucleotidesV3000(molBlock);
+  }
+
+  private getPolymerMolfile(monomerMolfiles: string[]) {
+    return this.linkV3000(monomerMolfiles);
+  }
+
+  private reflect(molBlock: string): string {
+    const coordinates = this.extractAtomDataV3000(molBlock);
+    const natom = coordinates.atomIndex.length;
+
+    const indexFivePrime = coordinates.atomIndex.indexOf(1);
+    const indexThreePrime = coordinates.atomIndex.indexOf(natom);
+
+    const xCenter = (coordinates.x[indexThreePrime] + coordinates.x[indexFivePrime]) / 2;
+    const yCenter = (coordinates.y[indexThreePrime] + coordinates.y[indexFivePrime]) / 2;
+
+    //place to center
+    for (let i = 0; i < natom; i++) {
+      coordinates.x[i] -= xCenter;
+      coordinates.y[i] -= yCenter;
+    }
+
+    //place to center
+    for (let i = 0; i < natom; i++)
+      coordinates.x[i] = -coordinates.x[i];
+
+    //place to right
+    const xShift = coordinates.x[indexFivePrime];
+    for (let i = 0; i < natom; i++)
+      coordinates.x[i] -= xShift;
+
+    //rewrite molBlock
+    let index = molBlock.indexOf('M  V30 BEGIN ATOM'); // V3000 index for atoms coordinates
+    index = molBlock.indexOf('\n', index);
+    let indexEnd = index;
+    for (let i = 0; i < natom; i++) {
+      index = molBlock.indexOf('V30', index) + 4;
+      index = molBlock.indexOf(' ', index) + 1;
+      index = molBlock.indexOf(' ', index) + 1;
+      indexEnd = molBlock.indexOf(' ', index) + 1;
+      indexEnd = molBlock.indexOf(' ', indexEnd);
+
+      molBlock = molBlock.slice(0, index) +
+        coordinates.x[i] + ' ' + coordinates.y[i] +
+        molBlock.slice(indexEnd);
+
+      index = molBlock.indexOf('\n', index) + 1;
+    }
+
+    return molBlock;
+  }
+
+  private extractAtomDataV3000(molBlock: string) {
+    const numbers = this.extractAtomsBondsNumbersV3000(molBlock);
+    let index = molBlock.indexOf('M  V30 BEGIN ATOM'); // V3000 index for atoms coordinates
+    index = molBlock.indexOf('\n', index);
+    let indexEnd = index;
+
+    const indexes: number[] = Array(numbers.natom);
+    const types: string[] = Array(numbers.natom);
+    const x: number[] = Array(numbers.natom);
+    const y: number[] = Array(numbers.natom);
+
+    for (let i = 0; i < numbers.natom; i++) {
+      index = molBlock.indexOf('V30', index) + 4;
+      indexEnd = molBlock.indexOf(' ', index);
+      indexes[i] = parseInt(molBlock.substring(index, indexEnd));
+
+      index = indexEnd + 1;
+      indexEnd = molBlock.indexOf(' ', index);
+      types[i] = molBlock.substring(index, indexEnd);
+
+      index = indexEnd + 1;
+      indexEnd = molBlock.indexOf(' ', index);
+      x[i] = parseFloat(molBlock.substring(index, indexEnd));
+
+      index = indexEnd + 1;
+      indexEnd = molBlock.indexOf(' ', index);
+      y[i] = parseFloat(molBlock.substring(index, indexEnd));
+
+      index = molBlock.indexOf('\n', index) + 1;
+    }
+
+    return {atomIndex: indexes, atomType: types, x: x, y: y};
+  }
+
+  private extractAtomsBondsNumbersV3000(molBlock: string): { natom: number, nbond: number } {
+    molBlock = molBlock.replaceAll('\r', ''); //equalize old and new sdf standards
+    let index = molBlock.indexOf('COUNTS') + 7; // V3000 index for atoms and bonds number
+    let indexEnd = molBlock.indexOf(' ', index);
+
+    const atomsNumber = parseInt(molBlock.substring(index, indexEnd));
+    index = indexEnd + 1;
+    indexEnd = molBlock.indexOf(' ', index);
+    const bondsNumber = parseInt(molBlock.substring(index, indexEnd));
+
+    return {natom: atomsNumber, nbond: bondsNumber};
+  }
+
+  private rotateNucleotidesV3000(molBlock: string): string {
+    const coordinates = this.extractAtomDataV3000(molBlock);
+    const natom = coordinates.atomIndex.length;
+
+    const indexFivePrime = coordinates.atomIndex.indexOf(1);
+    const indexThreePrime = coordinates.atomIndex.indexOf(natom);
+
+    //fix 5 prime if inadequate
+    if (natom > 8)
+      this.fix5Prime(coordinates, indexFivePrime, indexThreePrime);
+
+    const xCenter = (coordinates.x[indexThreePrime] + coordinates.x[indexFivePrime]) / 2;
+    const yCenter = (coordinates.y[indexThreePrime] + coordinates.y[indexFivePrime]) / 2;
+
+    //place to center
+    for (let i = 0; i < natom; i++) {
+      coordinates.x[i] -= xCenter;
+      coordinates.y[i] -= yCenter;
+    }
+
+    let angle = 0;
+    if (coordinates.x[indexFivePrime] === 0) {
+      angle = coordinates.y[indexFivePrime] > coordinates.y[indexThreePrime] ? Math.PI / 2 : 3 * Math.PI / 2;
+    } else if (coordinates.y[indexFivePrime] === 0) {
+      angle = coordinates.x[indexFivePrime] > coordinates.x[indexThreePrime] ? Math.PI : 0;
+    } else {
+      const derivative = coordinates.y[indexFivePrime] / coordinates.x[indexFivePrime];
+      angle = derivative > 0 ?
+        (coordinates.x[indexFivePrime] > 0 ? Math.PI - Math.atan(derivative) : Math.PI * 2 - Math.atan(derivative)) :
+        (coordinates.x[indexFivePrime] > 0 ? -Math.PI - Math.atan(derivative) : Math.atan(derivative));
+    }
+
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+
+    for (let i = 0; i < natom; i++) {
+      const xAdd = coordinates.x[i];
+      coordinates.x[i] = xAdd * cos - coordinates.y[i] * sin;
+      coordinates.y[i] = xAdd * sin + coordinates.y[i] * cos;
+    }
+
+    //place to right
+    const xShift = coordinates.x[indexFivePrime];
+    for (let i = 0; i < natom; i++)
+      coordinates.x[i] -= xShift;
+
+    //rewrite molBlock
+    let index = molBlock.indexOf('M  V30 BEGIN ATOM'); // V3000 index for atoms coordinates
+    index = molBlock.indexOf('\n', index);
+    let indexEnd = index;
+    for (let i = 0; i < natom; i++) {
+      index = molBlock.indexOf('V30', index) + 4;
+      index = molBlock.indexOf(' ', index) + 1;
+      index = molBlock.indexOf(' ', index) + 1;
+      indexEnd = molBlock.indexOf(' ', index) + 1;
+      indexEnd = molBlock.indexOf(' ', indexEnd);
+
+      molBlock = molBlock.slice(0, index) +
+        coordinates.x[i] + ' ' + coordinates.y[i] +
+        molBlock.slice(indexEnd);
+
+      index = molBlock.indexOf('\n', index) + 1;
+    }
+
+    return molBlock;
+  }
+
+
+  private linkV3000(molBlocks: string[], useChirality: boolean = true): string {
+    let macroMolBlock = '\nDatagrok macromolecule handler\n\n';
+    macroMolBlock += '  0  0  0  0  0  0            999 V3000\n';
+    macroMolBlock += 'M  V30 BEGIN CTAB\n';
+    let atomBlock = '';
+    let bondBlock = '';
+    let collectionBlock = '';
+    const collection: number [] = [];
+    let natom = 0;
+    let nbond = 0;
+    let xShift = 0;
+
+    for (let i = 0; i < molBlocks.length; i++) {
+      const isBoundary = molBlocks[i].includes('MODIFICATION') && i === 0;
+      let specLength = 0;
+      if (isBoundary) {
+        const coordinates = this.extractAtomDataV3000(molBlocks[i]);
+        specLength = coordinates.atomIndex.length;
+      }
+
+
+      molBlocks[i] = molBlocks[i].replaceAll('(-\nM  V30 ', '(')
+        .replaceAll('-\nM  V30 ', '').replaceAll(' )', ')');
+      const numbers = this.extractAtomsBondsNumbersV3000(molBlocks[i]);
+      const coordinates = this.extractAtomDataV3000(molBlocks[i]);
+
+      let indexAtoms = molBlocks[i].indexOf('M  V30 BEGIN ATOM'); // V3000 index for atoms coordinates
+      indexAtoms = molBlocks[i].indexOf('\n', indexAtoms);
+      let index = indexAtoms;
+      let indexEnd = indexAtoms;
+
+      for (let j = 0; j < numbers.natom; j++) {
+        if (coordinates.atomIndex[j] !== 1 || i === 0) {
+          //rewrite atom number
+          index = molBlocks[i].indexOf('V30', index) + 4;
+          indexEnd = molBlocks[i].indexOf(' ', index);
+          let atomNumber = 0;
+          if (isBoundary) {
+            atomNumber = parseInt(molBlocks[i].substring(index, indexEnd));
+            if (atomNumber === 1)
+              atomNumber = specLength;
+            else if (atomNumber === specLength)
+              atomNumber = 1;
+            atomNumber += natom;
+          } else {
+            atomNumber = parseInt(molBlocks[i].substring(index, indexEnd)) + natom;
+          }
+          molBlocks[i] = molBlocks[i].slice(0, index) + atomNumber + molBlocks[i].slice(indexEnd);
+
+          //rewrite coordinates
+          index = molBlocks[i].indexOf(' ', index) + 1;
+          index = molBlocks[i].indexOf(' ', index) + 1;
+          indexEnd = molBlocks[i].indexOf(' ', index);
+
+          const totalShift = xShift - coordinates.x[0];
+          let coordinate =
+            Math.round(10000 * (parseFloat(molBlocks[i].substring(index, indexEnd)) + totalShift)) / 10000;
+          molBlocks[i] = molBlocks[i].slice(0, index) + coordinate + molBlocks[i].slice(indexEnd);
+
+          index = molBlocks[i].indexOf(' ', index) + 1;
+          indexEnd = molBlocks[i].indexOf(' ', index);
+          coordinate =
+            Math.round(10000 * (parseFloat(molBlocks[i].substring(index, indexEnd)))) / 10000;
+          molBlocks[i] = molBlocks[i].slice(0, index) + coordinate + molBlocks[i].slice(indexEnd);
+
+          index = molBlocks[i].indexOf('\n', index) + 1;
+        } else {
+          index = molBlocks[i].indexOf('M  V30', index) - 1;
+          indexEnd = molBlocks[i].indexOf('\n', index + 1);
+          molBlocks[i] = molBlocks[i].slice(0, index) + molBlocks[i].slice(indexEnd);
+        }
+      }
+
+      const indexAtomsEnd = molBlocks[i].indexOf('M  V30 END ATOM');
+      atomBlock += molBlocks[i].substring(indexAtoms + 1, indexAtomsEnd);
+
+      let indexBonds = molBlocks[i].indexOf('M  V30 BEGIN BOND'); // V3000 index for bonds
+      indexBonds = molBlocks[i].indexOf('\n', indexBonds);
+      index = indexBonds;
+      indexEnd = indexBonds;
+
+      for (let j = 0; j < numbers.nbond; j++) {
+        //rewrite bond number
+        index = molBlocks[i].indexOf('V30', index) + 4;
+        indexEnd = molBlocks[i].indexOf(' ', index);
+        const bondNumber = parseInt(molBlocks[i].substring(index, indexEnd)) + nbond;
+        molBlocks[i] = molBlocks[i].slice(0, index) + bondNumber + molBlocks[i].slice(indexEnd);
+
+        //rewrite atom pair in bond
+        index = molBlocks[i].indexOf(' ', index) + 1;
+        index = molBlocks[i].indexOf(' ', index) + 1;
+        indexEnd = molBlocks[i].indexOf(' ', index);
+        let atomNumber = 0;
+        if (isBoundary) {
+          atomNumber = parseInt(molBlocks[i].substring(index, indexEnd));
+          if (atomNumber === 1)
+            atomNumber = specLength;
+          else if (atomNumber === specLength)
+            atomNumber = 1;
+          atomNumber += natom;
+        } else {
+          atomNumber = parseInt(molBlocks[i].substring(index, indexEnd)) + natom;
+        }
+
+        molBlocks[i] = molBlocks[i].slice(0, index) + atomNumber + molBlocks[i].slice(indexEnd);
+        index = molBlocks[i].indexOf(' ', index) + 1;
+        indexEnd = Math.min(molBlocks[i].indexOf('\n', index), molBlocks[i].indexOf(' ', index));
+        atomNumber = 0;
+        if (isBoundary) {
+          atomNumber = parseInt(molBlocks[i].substring(index, indexEnd));
+          if (atomNumber === 1)
+            atomNumber = specLength;
+          else if (atomNumber === specLength)
+            atomNumber = 1;
+          atomNumber += natom;
+        } else {
+          atomNumber = parseInt(molBlocks[i].substring(index, indexEnd)) + natom;
+        }
+        molBlocks[i] = molBlocks[i].slice(0, index) + atomNumber + molBlocks[i].slice(indexEnd);
+
+        index = molBlocks[i].indexOf('\n', index) + 1;
+      }
+
+      const indexBondEnd = molBlocks[i].indexOf('M  V30 END BOND');
+      bondBlock += molBlocks[i].substring(indexBonds + 1, indexBondEnd);
+
+      let indexCollection = molBlocks[i].indexOf('M  V30 MDLV30/STEABS ATOMS=('); // V3000 index for collections
+
+      while (indexCollection !== -1) {
+        indexCollection += 28;
+        const collectionEnd = molBlocks[i].indexOf(')', indexCollection);
+        const collectionEntries = molBlocks[i].substring(indexCollection, collectionEnd).split(' ').slice(1);
+        collectionEntries.forEach((e) => {
+          collection.push(parseInt(e) + natom);
+        });
+        indexCollection = collectionEnd;
+        indexCollection = molBlocks[i].indexOf('M  V30 MDLV30/STEABS ATOMS=(', indexCollection);
+      }
+
+      natom += numbers.natom - 1;
+      nbond += numbers.nbond;
+      if (isBoundary)
+        xShift += Math.max(...coordinates.x);
+      else
+        xShift += coordinates.x[numbers.natom - 1] - coordinates.x[0];
+    }
+
+    const entries = 4;
+    const collNumber = Math.ceil(collection.length / entries);
+
+    collectionBlock += 'M  V30 MDLV30/STEABS ATOMS=(' + collection.length + ' -\n';
+    for (let i = 0; i < collNumber; i++) {
+      collectionBlock += 'M  V30 ';
+      const entriesCurrent = i + 1 === collNumber ? collection.length - (collNumber - 1) * entries : entries;
+      for (let j = 0; j < entriesCurrent; j++) {
+        collectionBlock += (j + 1 === entriesCurrent) ?
+          (i === collNumber - 1 ? collection[entries * i + j] + ')\n' : collection[entries * i + j] + ' -\n') :
+          collection[entries * i + j] + ' ';
+      }
+    }
+
+    //generate file
+    natom++;
+    macroMolBlock += 'M  V30 COUNTS ' + natom + ' ' + nbond + ' 0 0 0\n';
+    macroMolBlock += 'M  V30 BEGIN ATOM\n';
+    macroMolBlock += atomBlock;
+    macroMolBlock += 'M  V30 END ATOM\n';
+    macroMolBlock += 'M  V30 BEGIN BOND\n';
+    macroMolBlock += bondBlock;
+    macroMolBlock += 'M  V30 END BOND\n';
+    if (useChirality && collection.length > 0) {
+      macroMolBlock += 'M  V30 BEGIN COLLECTION\n';
+      macroMolBlock += collectionBlock;
+      macroMolBlock += 'M  V30 END COLLECTION\n';
+    } else { macroMolBlock = macroMolBlock.replace(/ CFG=\d/g, ' '); }
+
+    macroMolBlock += 'M  V30 END CTAB\n';
+    macroMolBlock += 'M  END';
+
+    return macroMolBlock;
+  }
+
+  private fix5Prime(coordinates: { atomIndex: number[], atomType: string[], x: number[], y: number[] },
+    indexFivePrime: number, indexThreePrime: number) {
+    const indexFivePrimeNeighbour = indexFivePrime + 1;
+    const xShift = coordinates.x[indexFivePrimeNeighbour];
+    const yShift = coordinates.y[indexFivePrimeNeighbour];
+    const base3PrimeX = coordinates.x[indexThreePrime] - xShift;
+    const base3PrimeY = coordinates.y[indexThreePrime] - yShift;
+    const base5PrimeX = coordinates.x[indexFivePrime] - xShift;
+    const base5PrimeY = coordinates.y[indexFivePrime] - yShift;
+
+    const rotated5PrimeX = base5PrimeX * Math.cos(Math.PI * 2 / 3) - base5PrimeY * Math.sin(Math.PI * 2 / 3);
+    const rotated5PrimeY = base5PrimeX * Math.sin(Math.PI * 2 / 3) + base5PrimeY * Math.cos(Math.PI * 2 / 3);
+
+    const dx = base5PrimeX - base3PrimeX;
+    const dy = base5PrimeY - base3PrimeY;
+    const dxRotated = rotated5PrimeX - base3PrimeX;
+    const dyRotated = rotated5PrimeY - base3PrimeY;
+
+    if (Math.sqrt(dyRotated * dyRotated + dxRotated * dxRotated) >= Math.sqrt(dy * dy + dx * dx)) {
+      coordinates.x[indexFivePrime] = rotated5PrimeX + xShift;
+      coordinates.y[indexFivePrime] = rotated5PrimeY + yShift;
+    }
+  }
+}

package/src/package-test.ts

@@ -1,6 +1,8 @@
 import * as DG from 'datagrok-api/dg';
 import {runTests, tests, TestContext} from '@datagrok-libraries/utils/src/test';
-import './tests/smiles-tests';
+import './tests/formats-to-helm';
+import './tests/helm-to-nucleotides';
+import './tests/formats-support';
 
 export const _package = new DG.Package();
 export {tests};

package/src/package.ts

@@ -2,111 +2,133 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {autostartOligoSdFileSubscription} from './autostart/registration';
-import {OligoSdFileApp} from './apps/oligo-sd-file-app';
-
-// three tabs of the app's view
-import {getMainTab} from './main-tab/main-tab';
-import {getAxolabsTab} from './axolabs-tab/axolabs-tab';
-import {getSdfTab} from './sdf-tab/sdf-tab';
-
-const MAIN = 'MAIN';
-const AXOLABS = 'AXOLABS';
-const SDF = 'SDF';
-
-const SEQUENCE_TRANSLATOR = 'Sequence Translator';
-const DEFAULT_SEQUENCE = 'fAmCmGmAmCpsmU';
-const DEFAULT_LIB_FILENAME = 'helmLib.json';
+import {SequenceTranslatorUI} from './view/view';
+import {LIB_PATH, DEFAULT_LIB_FILENAME} from './model/data-loading-utils/const';
+import {IMonomerLib} from '@datagrok-libraries/bio/src/types';
+import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import {getJsonData} from './model/data-loading-utils/json-loader';
+import {SequenceToMolfileConverter} from './model/sequence-to-structure-utils/sequence-to-molfile';
+import {linkStrandsV3000} from './model/sequence-to-structure-utils/mol-transformations';
+import {MonomerLibWrapper} from './model/monomer-lib/lib-wrapper';
+import {FormatDetector} from './model/parsing-validation/format-detector';
+import {SequenceValidator} from './model/parsing-validation/sequence-validator';
+import {demoDesignPatternUI, demoVisualizeDuplexUI, demoTranslateSequenceUI} from './demo/demo-st-ui';
+import {FormatConverter} from './model/format-translation/format-converter';
+
+class StPackage extends DG.Package {
+  private _monomerLib?: IMonomerLib;
+
+  get monomerLib(): IMonomerLib {
+    if (!this._monomerLib)
+      throw new Error ('ST: monomer lib not loaded')
+    return this._monomerLib!;
+  }
 
-import {IMonomerLib, MonomerWorks, readLibrary} from '@datagrok-libraries/bio';
+  public async initMonomerLib(): Promise<void> {
+    if (this._monomerLib !== undefined)
+      return;
+
+    const pi: DG.TaskBarProgressIndicator = DG.TaskBarProgressIndicator.create(
+      'Initializing Sequence Translator monomer library ...');
+    try {
+      const libHelper: IMonomerLibHelper = await getMonomerLibHelper();
+      this._monomerLib = await libHelper.readLibrary(LIB_PATH, DEFAULT_LIB_FILENAME);
+    } catch (err: any) {
+      const errMsg: string = err.hasOwnProperty('message') ? err.message : err.toString();
+      throw new Error('Loading monomer library: ' + errMsg);
+    } finally {
+      pi.close();
+    }
+  }
+}
 
-export const _package = new DG.Package();
+export const _package: StPackage = new StPackage();
 
-const LIB_PATH = 'System:AppData/SequenceTranslator';
+//name: Sequence Translator
+//tags: app
+export async function sequenceTranslatorApp(): Promise<void> {
+  const pi: DG.TaskBarProgressIndicator = DG.TaskBarProgressIndicator.create('Loading Sequence Translator app ...');
 
-let monomerLib: IMonomerLib | null = null;
-export let monomerWorks: MonomerWorks | null = null;
+  try {
+    await initSequenceTranslatorLibData();
+    const v = new SequenceTranslatorUI();
+    await v.createLayout();
+  } catch (err: any) {
+    const errMsg: string = err.hasOwnProperty('message') ? err.message : err.toString();
+    grok.shell.error(`Loading Sequence Translator application error: ` + errMsg);
+    throw err;
+  } finally {
+    pi.close();
+  }
+}
 
-export function getMonomerWorks() {
-  return monomerWorks;
+//name: initSequenceTranslatorLibData
+export async function initSequenceTranslatorLibData(): Promise<void> {
+  await getJsonData();
+  await _package.initMonomerLib();
 }
 
-export function getMonomerLib() {
-  return monomerLib;
+//name: getCodeToWeightsMap
+//output: object result
+export function getCodeToWeightsMap(): {[key: string]: number} {
+  const map = MonomerLibWrapper.getInstance().getCodesToWeightsMap();
+  return Object.fromEntries(map);
 }
 
-//name: Sequence Translator
-//tags: app
-export async function sequenceTranslator(): Promise<void> {
-  monomerLib = await readLibrary(LIB_PATH, DEFAULT_LIB_FILENAME);
-
-  if (monomerWorks === null)
-    monomerWorks = new MonomerWorks(monomerLib);
-
-  const windows = grok.shell.windows;
-  windows.showProperties = false;
-  windows.showToolbox = false;
-  windows.showHelp = false;
-
-  let urlParams = new URLSearchParams(window.location.search);
-
-  let mainSeq: string = DEFAULT_SEQUENCE;
-  const view = grok.shell.newView(SEQUENCE_TRANSLATOR, []);
-  view.box = true;
-
-  const tabControl = ui.tabControl({
-    [MAIN]: await getMainTab((seq) => {
-      mainSeq = seq;
-      urlParams = new URLSearchParams();
-      urlParams.set('seq', mainSeq);
-      updatePath();
-    }),
-    [AXOLABS]: getAxolabsTab(),
-    [SDF]: getSdfTab(),
-  });
-
-  tabControl.onTabChanged.subscribe(() => {
-    if (tabControl.currentPane.name !== MAIN)
-      urlParams.delete('seq');
-    else
-      urlParams.set('seq', mainSeq);
-    updatePath();
-  });
-
-  function updatePath() {
-    const urlParamsTxt: string = Object.entries(urlParams)
-      .map(([key, value]) => `${key}=${encodeURIComponent(value)}`).join('&');
-    view.path = '/apps/SequenceTranslator/SequenceTranslator' + `/${tabControl.currentPane.name}/?${urlParamsTxt}`;
-  }
+//name: validateSequence
+//input: string sequence
+//output: bool result
+export function validateSequence(sequence: string): boolean {
+  const validator = new SequenceValidator(sequence);
+  const format = (new FormatDetector(sequence).getFormat());
+  return (format === null) ? false : validator.isValidSequence(format!);
+}
 
-  const pathParts: string[] = window.location.pathname.split('/');
-  if (pathParts.length >= 5) {
-    const tabName: string = pathParts[5];
-    tabControl.currentPane = tabControl.getPane(tabName);
-  }
+//name: validateSequence
+//input: string sequence
+//input: bool invert
+//output: string result
+export function getMolfileFromGcrsSequence(sequence: string, invert: boolean): string {
+  return (new SequenceToMolfileConverter(sequence, invert, 'GCRS')).convert();
+}
 
-  view.append(tabControl);
-  // console.debug('SequenceTranslator: app sequenceTranslator() ' + `view.path='${view.path}', view.basePath='${view.basePath}'.`);
+//name: linkStrands
+//input: object strands
+//output: string result
+export function linkStrands(strands: { senseStrands: string[], antiStrands: string[] }): string {
+  return linkStrandsV3000(strands, true);
 }
 
-//tags: autostart
-export async function autostartST() {
-  autostartOligoSdFileSubscription();
-};
+//name: demoTranslateSequence
+//meta.demoPath: Bioinformatics | Oligonucleotide Sequence: Translate
+//description: Translate oligonucleotide sequences across various formats accepted by different synthesizers
+//meta.path: /apps/Tutorials/Demo/Bioinformatics/Oligonucleotide%20Sequence:%20Translate
+export async function demoTranslateSequence(): Promise<void> {
+  await demoTranslateSequenceUI();
+}
 
-//name: oligoSdFileApp
-//description: Test/demo app for oligoSdFile
-export async function oligoSdFileApp() {
-  // console.debug('SequenceTranslator: package.ts oligoSdFileApp()');
+//name: demoDesignPattern
+//meta.demoPath: Bioinformatics | Oligonucleotide Sequence: Design
+//description: Design a modification pattern for an oligonucleotide sequence
+//meta.path:%20/apps/Tutorials/Demo/Bioinformatics/Oligonucleotide%20Sequence:%20Visualize%20duplex
+export async function demoDesignPattern(): Promise<void> {
+  await demoDesignPatternUI();
+}
 
-  const pi = DG.TaskBarProgressIndicator.create('open oligoSdFile app');
-  try {
-    grok.shell.windows.showProperties = false;
-    grok.shell.windows.showHelp = false;
+//name: demoVisualizeDuplex
+//meta.demoPath: Bioinformatics | Oligonucleotide Sequence: Visualize duplex
+//description: Visualize duplex and save SDF
+//meta.path:%20/apps/Tutorials/Demo/Bioinformatics/Oligonucleotide%20Sequence:%20Visualize%20duplex
+export async function demoVisualizeDuplex(): Promise<void> {
+  await demoVisualizeDuplexUI();
+}
 
-    const app = new OligoSdFileApp();
-    await app.init();
-  } finally {
-    pi.close();
-  }
+//name: translateOligonucleotideSequence
+//input: string sequence
+//input: string sourceFormat
+//input: string targetFormat
+//output: string result
+export async function translateOligonucleotideSequence(sequence: string, sourceFormat: string, targetFormat: string): Promise<string> {
+  await initSequenceTranslatorLibData();
+  return (new FormatConverter(sequence, sourceFormat)).convertTo(targetFormat);
 }

package/src/tests/const.ts

@@ -0,0 +1,24 @@
+type Dict = {[key: string]: string};
+
+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)}$$$$'
+  },
+  'BioSpring': {
+    'AT*GC*123456789': 'RNA1{r(A)p.r(T)[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])}$$$$'
+  },
+  'Mermade12': {
+    'hefglijkLIJKHEFG': '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)}$$$$'
+  }
+}
+
+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)p.r(T)[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])}$$$$': 'ATGCUACGUACGC',
+
+  '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 = {
+}