@datagrok/sequence-translator 1.0.15 → 1.0.17

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

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

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

@@ -1,5 +1,5 @@
-import {AXOLABS_MAP} from './constants';
-import {NUCLEOTIDES} from '../structures-works/map';
+import {AXOLABS_MAP} from '../hardcode-to-be-eliminated/constants';
+import {NUCLEOTIDES} from '../hardcode-to-be-eliminated/map';
 
 export function isOverhang(modification: string): boolean {
   return modification.slice(-3) == '(o)';

package/src/{structures-works → hardcode-to-be-eliminated}/converters.ts

@@ -1,7 +1,7 @@
 import {lcmsToGcrs, MODIFICATIONS} from './map';
 import * as DG from 'datagrok-api/dg';
 import {DELIMITER} from './map';
-import {sortByStringLengthInDescendingOrder} from '../helpers';
+import {sortByStringLengthInDescendingOrder} from '../utils/helpers';
 //name: gcrsToLcms
 //input: string nucleotides {semType: GCRS}
 //output: string result {semType: LCMS}

package/src/{structures-works → hardcode-to-be-eliminated}/map.ts

@@ -1,6 +1,6 @@
 import * as DG from 'datagrok-api/dg';
-import {getAllCodesOfSynthesizer} from './sequence-codes-tools';
-import {differenceOfTwoArrays} from '../helpers';
+import {getAllCodesOfSynthesizer} from '../sdf-tab/sequence-codes-tools';
+import {differenceOfTwoArrays} from '../utils/helpers';
 
 export const DELIMITER = ';';
 export const NUCLEOTIDES = ['A', 'G', 'C', 'U', 'T'];

package/src/{main/main-view.ts → main-tab/main-tab.ts}

@@ -3,27 +3,31 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import * as rxjs from 'rxjs';
-import {convertSequence, undefinedInputSequence, isValidSequence} from '../structures-works/sequence-codes-tools';
-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';
-import {extractAtomDataV3000} from '../structures-works/mol-transformations';
-import {errorToConsole} from '@datagrok-libraries/utils/src/to-console';
+
+import {convertSequence, undefinedInputSequence, isValidSequence} from '../sdf-tab/sequence-codes-tools';
+
+// todo: elminate completely
+import {map} from '../hardcode-to-be-eliminated/map';
+import {MODIFICATIONS} from '../hardcode-to-be-eliminated/const';
+
+// todo: unify with lib bio monomers works
+import {sequenceToSmiles, sequenceToMolV3000} from '../utils/structures-works/from-monomers';
+import {drawMolecule} from '../utils/structures-works/draw-molecule';
+
+import {download} from '../utils/helpers';
 
 const defaultInput = 'fAmCmGmAmCpsmU'; // todo: capitalize constants
 const sequenceWasCopied = 'Copied'; // todo: wrap hardcoded literals into constants
 const tooltipSequence = 'Copy sequence';
 
-export async function mainView(): Promise<HTMLDivElement> {
+export async function getMainTab(onSequenceChanged: (seq: string) => void): Promise<HTMLDivElement> {
   const onInput: rxjs.Subject<string> = new rxjs.Subject<string>();
 
   async function updateTableAndMolecule(sequence: string, inputFormat: string): Promise<void> {
-    moleculeSvgDiv.innerHTML = '';
+    moleculeImgDiv.innerHTML = '';
     outputTableDiv.innerHTML = '';
     const pi = DG.TaskBarProgressIndicator.create('Rendering table and molecule...');
-    let errorsExist = false;
 
     try {
       sequence = sequence.replace(/\s/g, '');
@@ -57,77 +61,20 @@ export async function mainView(): Promise<HTMLDivElement> {
         ui.div([
           DG.HtmlTable.create(tableRows, (item: { key: string; value: string; }) =>
             [item.key, item.value], ['Code', 'Sequence']).root,
-        ]),
+        ])
       );
 
-      if (outputSequenceObj.type != undefinedInputSequence && outputSequenceObj.Error != undefinedInputSequence) {
+      if (outputSequenceObj.type !== undefinedInputSequence && outputSequenceObj.Error !== undefinedInputSequence) {
         const formCanvasWidth = 500;
         const formCanvasHeight = 170;
-        const formCanvas = ui.canvas(
-          formCanvasWidth * window.devicePixelRatio, formCanvasHeight * window.devicePixelRatio);
-        formCanvas.style.width = `${formCanvasWidth}px`;
-        formCanvas.style.height = `${formCanvasHeight}px`;
-
-        formCanvas.addEventListener('click', async () => {
-          try {
-            const mol = sequenceToMolV3000(
-              inputSequenceField.value.replace(/\s/g, ''), false, true,
-              output.synthesizer![0],
-            );
-            console.log(mol);
-
-            const addDiv = ui.div([], {style: {overflowX: 'scroll'}});
-
-            // addDiv size required, but now available before dialog show()
-            const coordinates = extractAtomDataV3000(mol);
-            const cw: number = $(window).width() * 0.80; // addDiv.clientWidth
-            const ch: number = $(window).height() * 0.70; // addDiv.clientHeight
-            const molWidth: number = Math.max(...coordinates.x) - Math.min(...coordinates.x);
-            const molHeight: number = Math.max(...coordinates.y) - Math.min(...coordinates.y);
-
-            const wR: number = cw / molWidth;
-            const hR: number = ch / molHeight;
-            const r: number = hR; // Math.max(wR, hR);
-            const dlgCanvasWidth = r * molWidth;
-            const dlgCanvasHeight = r * molHeight;
-
-            const dlgCanvas = ui.canvas(dlgCanvasWidth * window.devicePixelRatio, dlgCanvasHeight * window.devicePixelRatio);
-            dlgCanvas.style.width = `${dlgCanvasWidth}px`;
-            dlgCanvas.style.height = `${dlgCanvasHeight}px`;
-
-            // // @ts-ignore
-            // OCL.StructureView.drawMolecule(dlgCanvas, OCL.Molecule.fromMolfile(mol), {suppressChiralText: true});
-            // await grok.chem.canvasMol(0, 0, dlgCanvas.width, dlgCanvas.height, dlgCanvas, mol, null,
-            //   {setNewCoords: false, normalizeDepiction: false, straightenDepiction: false});
-            await grok.functions.call('Chem:canvasMol', {
-              x: 0, y: 0, w: dlgCanvas.width, h: dlgCanvas.height, canvas: dlgCanvas,
-              molString: mol, scaffoldMolString: '',
-              options: {setNewCoords: false, normalizeDepiction: false, straightenDepiction: false}
-            });
-
-            addDiv.appendChild(dlgCanvas);
-            ui.dialog('Molecule: ' + inputSequenceField.value)
-              .add(addDiv)
-              .showModal(true);
-          } catch (err) {
-            const errStr = errorToConsole(err);
-            console.error(errStr);
-          }
-        });
-        $(formCanvas).on('mouseover', () => $(formCanvas).css('cursor', 'zoom-in'));
-        $(formCanvas).on('mouseout', () => $(formCanvas).css('cursor', 'default'));
-        const mol = sequenceToMolV3000(inputSequenceField.value.replace(/\s/g, ''), false, true,
-          output.synthesizer![0]);
-        // // @ts-ignore
-        // OCL.StructureView.drawMolecule(formCanvas, OCL.Molecule.fromMolfile(mol), {suppressChiralText: true});
-        await grok.functions.call('Chem:canvasMol', {
-          x: 0, y: 0, w: formCanvas.width, h: formCanvas.height, canvas: formCanvas,
-          molString: mol, scaffoldMolString: '',
-          options: {setNewCoords: false, normalizeDepiction: false, straightenDepiction: false}
-        });
-        moleculeSvgDiv.append(formCanvas);
-      } else
-        moleculeSvgDiv.innerHTML = '';
+        const molfile = sequenceToMolV3000(
+          inputSequenceField.value.replace(/\s/g, ''), false, true,
+          output.synthesizer![0]
+        );
+        await drawMolecule(moleculeImgDiv, formCanvasWidth, formCanvasHeight, molfile);
+      } else {
+        moleculeImgDiv.innerHTML = '';
+      }
     } finally {
       pi.close();
     }
@@ -137,7 +84,7 @@ export async function mainView(): Promise<HTMLDivElement> {
   inputFormatChoiceInput.onInput((format: string) => {
     updateTableAndMolecule(inputSequenceField.value.replace(/\s/g, ''), format);
   });
-  const moleculeSvgDiv = ui.block([]);
+  const moleculeImgDiv = ui.block([]);
   const outputTableDiv = ui.div([]);
   const inputSequenceField = ui.textInput('', defaultInput, (sequence: string) => {
     // Send event to DG.debounce()
@@ -146,6 +93,7 @@ export async function mainView(): Promise<HTMLDivElement> {
 
   DG.debounce<string>(onInput, 300).subscribe((sequence) => {
     updateTableAndMolecule(sequence, inputFormatChoiceInput.value!);
+    onSequenceChanged(sequence);
   });
 
   const asoGapmersGrid = DG.Viewer.grid(
@@ -228,7 +176,7 @@ export async function mainView(): Promise<HTMLDivElement> {
   const topPanel = [
     downloadMolFileIcon,
     copySmilesIcon,
-    switchInput.root,
+    switchInput.root, // todo: remove from top panel
   ];
 
   const v = grok.shell.v;
@@ -253,7 +201,7 @@ export async function mainView(): Promise<HTMLDivElement> {
             ui.h1('Output'),
             outputTableDiv,
           ]),
-          moleculeSvgDiv,
+          moleculeImgDiv,
         ], 'sequence'),
       ]),
       codesTablesDiv,

package/src/package.ts

@@ -1,10 +1,23 @@
 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 {defineAxolabsPattern} from './axolabs/define-pattern';
-import {saveSenseAntiSense} from './structures-works/save-sense-antisense';
-import {mainView} from './main/main-view';
+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 {IMonomerLib, MonomerWorks, readLibrary} from '@datagrok-libraries/bio';
 
 export const _package = new DG.Package();
@@ -25,9 +38,9 @@ export function getMonomerLib() {
 //name: Sequence Translator
 //tags: app
 export async function sequenceTranslator(): Promise<void> {
-  monomerLib = await readLibrary(LIB_PATH, 'helmLib.json');
+  monomerLib = await readLibrary(LIB_PATH, DEFAULT_LIB_FILENAME);
 
-  if (monomerWorks == null)
+  if (monomerWorks === null)
     monomerWorks = new MonomerWorks(monomerLib);
 
   const windows = grok.shell.windows;
@@ -35,14 +48,65 @@ export async function sequenceTranslator(): Promise<void> {
   windows.showToolbox = false;
   windows.showHelp = false;
 
-  const v = grok.shell.newView('Sequence Translator', []);
-  v.box = true;
-  v.append(ui.tabControl({
-    'MAIN': await mainView(),
-    'AXOLABS': defineAxolabsPattern(),
-    'SDF': saveSenseAntiSense(),
-  }));
+  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}`;
+  }
+
+  const pathParts: string[] = window.location.pathname.split('/');
+  if (pathParts.length >= 5) {
+    const tabName: string = pathParts[5];
+    tabControl.currentPane = tabControl.getPane(tabName);
+  }
+
+  view.append(tabControl);
+  // console.debug('SequenceTranslator: app sequenceTranslator() ' + `view.path='${view.path}', view.basePath='${view.basePath}'.`);
 }
 
 //tags: autostart
-autostartOligoSdFileSubscription();
+export async function autostartST() {
+  autostartOligoSdFileSubscription();
+};
+
+//name: oligoSdFileApp
+//description: Test/demo app for oligoSdFile
+export async function oligoSdFileApp() {
+  // console.debug('SequenceTranslator: package.ts oligoSdFileApp()');
+
+  const pi = DG.TaskBarProgressIndicator.create('open oligoSdFile app');
+  try {
+    grok.shell.windows.showProperties = false;
+    grok.shell.windows.showHelp = false;
+
+    const app = new OligoSdFileApp();
+    await app.init();
+  } finally {
+    pi.close();
+  }
+}

package/src/sdf-tab/sdf-tab.ts

@@ -0,0 +1,163 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+import * as rxjs from 'rxjs';
+import {errorToConsole} from '@datagrok-libraries/utils/src/to-console';
+
+import $ from 'cash-dom';
+
+import {download} from '../utils/helpers';
+
+import {sequenceToMolV3000} from '../utils/structures-works/from-monomers';
+import {linkStrandsV3000} from '../utils/structures-works/mol-transformations';
+import {getFormat} from './sequence-codes-tools';
+
+import {drawMolecule} from '../utils/structures-works/draw-molecule';
+
+function getMolfileForImg(
+  ss: string, as: string,
+  as2: string | null = null,
+  invertSS: boolean, invertAS: boolean, invertAS2: boolean,
+  useChiral: boolean
+): string {
+  const formatAs = getFormat(as);
+  const formatSs = getFormat(ss);
+  let formatAs2: string | null = null;
+  let molAS2: string | null = null;
+
+  let molSS = '';
+  let molAS = '';
+  try {
+    // a workaround to get the SS depicted in case AS is empty
+    molSS = sequenceToMolV3000(ss, invertSS, false, formatSs!);
+    molAS = sequenceToMolV3000(as, invertAS, false, formatAs!);
+  } catch (err) {
+    const errStr = errorToConsole(err);
+    console.error(errStr);
+  }
+
+  if (as2 !== null && as2 !== '') {
+    formatAs2 = getFormat(as2!);
+    molAS2 = sequenceToMolV3000(as2, invertAS2!, false, formatAs2!);
+  }
+
+  const antiStrands = molAS2 === null ? [molAS] : [molAS, molAS2];
+  const resultingMolfile = linkStrandsV3000({senseStrands: [molSS], antiStrands: antiStrands}, useChiral);
+  return resultingMolfile;
+}
+
+export function saveSdf(as: string, ss: string,
+  oneEntity: boolean, useChiral: boolean,
+  invertSS: boolean, invertAS: boolean,
+  as2: string | null = null, invertAS2: boolean | null
+): void {
+  const formatAs = getFormat(as);
+  const formatSs = getFormat(ss);
+  let formatAs2: string | null = null;
+  let molAS2: string | null = null;
+
+  const molSS = sequenceToMolV3000(ss, invertSS, false, formatSs!);
+  const molAS = sequenceToMolV3000(as, invertAS, false, formatAs!);
+
+  if (as2 !== null && as2 !== '') {
+    formatAs2 = getFormat(as2!);
+    molAS2 = sequenceToMolV3000(as2, invertAS2!, false, formatAs2!);
+  }
+
+  let result: string;
+  if (oneEntity) {
+    const antiStrands = molAS2 === null ? [molAS] : [molAS, molAS2];
+    result = linkStrandsV3000({senseStrands: [molSS], antiStrands: antiStrands}, useChiral) + '\n$$$$\n';
+  } else {
+    result =
+    molSS + '\n' +
+    `> <Sequence>\nSense Strand\n$$$$\n` +
+    molAS + '\n' +
+    `> <Sequence>\nAnti Sense\n$$$$\n`;
+
+    if (molAS2) {
+      result += molAS2+ '\n' +
+      `> <Sequence>\nAnti Sense 2\n$$$$\n`;
+    }
+  }
+
+  // construct date-time in the form yyyy-mm-dd_hh-mm-ss
+  const date = new Date();
+  function pad(x: number): string {
+    return (x >= 10) ? x.toString() : '0' + x.toString();
+  }
+  const dateString: string = date.getFullYear() + '-' + pad(date.getMonth() + 1) +
+                      '-' + pad(date.getDate()) + '_' + pad(date.getHours()) + '-' +
+                      pad(date.getMinutes()) + '-' + pad(date.getSeconds());
+
+  download(`SequenceTranslator-${dateString}.sdf`, encodeURIComponent(result));
+}
+
+/** UI of the SDF tab on the application's view */
+export function getSdfTab(): HTMLDivElement {
+  const onInput: rxjs.Subject<string> = new rxjs.Subject<string>();
+
+  // inputs
+  const inputColHeader = ui.h1('Sequences');
+  const ssInput = ui.textInput('Sense Strand', '', () => { onInput.next(); });
+  ssInput.root.style.color = 'red';
+  const asInput = ui.textInput('Anti Sense', '', () => { onInput.next(); });
+  const as2Input = ui.textInput('Anti Sense 2', '', () => { onInput.next(); });
+  const saveEntity = ui.boolInput('Save as one entity', true);
+  const useChiralInput = ui.boolInput('Use chiral', true);
+
+  // default values
+  const straight = '5 prime -> 3 prime';
+  const inverse = '3 prime -> 5 prime';
+  let invertSS = false;
+  let invertAS = false;
+  const invertAS2 = false;
+
+  // choice inputs
+  const ssDirection = ui.choiceInput('SS direction', straight, [straight, inverse]);
+  ssDirection.onChanged(() => { invertSS = ssDirection.value === inverse; });
+  const asDirection = ui.choiceInput('AS direction', straight, [straight, inverse]);
+  asDirection.onChanged(() => { invertAS = asDirection.value === inverse; });
+  const as2Direction = ui.choiceInput('AS 2 direction', straight, [straight, inverse]);
+  as2Direction.onChanged(() => { invertAS = asDirection.value === inverse; });
+
+  // molecule image
+  const moleculeImgDiv = ui.block([]);
+  DG.debounce<string>(onInput, 300).subscribe(async () => {
+    let molfile = '';
+    try {
+      molfile = getMolfileForImg(
+        ssInput.value, asInput.value, as2Input.value, invertSS, invertAS, invertAS2, useChiralInput.value!
+      );
+    } catch (err) {
+      const errStr = errorToConsole(err);
+      console.error(errStr);
+    }
+    // todo: calculate relative numbers
+    const canvasWidth = 500;
+    const canvasHeight = 170;
+    // todo: remove div with image if molfile empty
+    await drawMolecule(moleculeImgDiv, canvasWidth, canvasHeight, molfile);
+  });
+
+  const saveButton = ui.buttonsInput([
+    ui.bigButton('Save SDF', () =>
+      saveSdf(
+        asInput.value, ssInput.value, saveEntity.value!,
+        useChiralInput.value!, invertSS, invertAS, as2Input.value, invertAS2)
+    )
+  ]);
+  //@ts-ignore
+  // the above line is recommended by Dmitry because saveButton has wrong return
+  // type
+  const form1 = ui.form([inputColHeader, ssInput, asInput, as2Input, saveButton]);
+  form1.className = 'ui-form ui-form-wide';
+  const form2 = ui.form([ssDirection, asDirection, as2Direction, saveEntity, useChiralInput]);
+  form2.className = 'ui-form ui-form-wide';
+
+  const body = ui.divV([ui.divH([ui.block([form1]), form2]), moleculeImgDiv]);
+  $(form1).find('textarea').css('flex-grow', '1');
+  $(form1).find('label').css('max-width', '140px');
+
+  return body;
+}

package/src/{structures-works → sdf-tab}/sequence-codes-tools.ts

@@ -1,12 +1,15 @@
-
-import {map, SYNTHESIZERS, TECHNOLOGIES, MODIFICATIONS, DELIMITER, gcrsCodesWithoutSmiles, NUCLEOTIDES} from './map';
-import {sortByStringLengthInDescendingOrder} from '../helpers';
-import {asoGapmersNucleotidesToBioSpring, asoGapmersNucleotidesToGcrs,
+import {
+  map, SYNTHESIZERS, TECHNOLOGIES, MODIFICATIONS, DELIMITER, gcrsCodesWithoutSmiles, NUCLEOTIDES
+} from '../hardcode-to-be-eliminated/map';
+import {sortByStringLengthInDescendingOrder} from '../utils/helpers';
+import {
+  asoGapmersNucleotidesToBioSpring, asoGapmersNucleotidesToGcrs,
   asoGapmersBioSpringToNucleotides, asoGapmersBioSpringToGcrs, gcrsToMermade12, siRnaNucleotideToBioSpringSenseStrand,
   siRnaNucleotideToAxolabsSenseStrand, siRnaNucleotidesToGcrs, siRnaBioSpringToNucleotides,
   siRnaBioSpringToAxolabs, siRnaBioSpringToGcrs, siRnaAxolabsToNucleotides,
   siRnaAxolabsToBioSpring, siRnaAxolabsToGcrs, siRnaGcrsToNucleotides,
-  siRnaGcrsToBioSpring, siRnaGcrsToAxolabs, gcrsToNucleotides, gcrsToLcms} from './converters';
+  siRnaGcrsToBioSpring, siRnaGcrsToAxolabs, gcrsToNucleotides, gcrsToLcms
+} from '../hardcode-to-be-eliminated/converters';
 
 const noTranslationTableAvailable = 'No translation table available';
 export const undefinedInputSequence = 'Type of input sequence is undefined';

package/src/tests/smiles-tests.ts

@@ -1,6 +1,6 @@
 import {category, expect, test} from '@datagrok-libraries/utils/src/test';
-import {sequenceToSmiles} from '../structures-works/from-monomers';
-import {SYNTHESIZERS} from '../structures-works/map';
+import {sequenceToSmiles} from '../utils/structures-works/from-monomers';
+import {SYNTHESIZERS} from '../hardcode-to-be-eliminated/map';
 
 category('sequence-translator', () => {
   // test('AGGTCCTCTTGACTTAGGCC', async () => {

package/src/{helpers.ts → utils/helpers.ts}

@@ -1,9 +1,9 @@
 import * as DG from 'datagrok-api/dg';
 
 export function sortByStringLengthInDescendingOrder(array: string[]): string[] {
-  return array.sort(function(a, b) {return b.length - a.length;});
+  return array.sort(function(a, b) { return b.length - a.length; });
 }
-  
+
 export function stringify(items: string[]): string {
   return '["' + items.join('", "') + '"]';
 }
@@ -17,7 +17,7 @@ export function download(name: string, href: string): void {
 
 export function removeEmptyRows(t: DG.DataFrame, colToCheck: DG.Column): DG.DataFrame {
   for (let i = t.rowCount - 1; i > -1; i--) {
-    if (colToCheck.getString(i) == '')
+    if (colToCheck.getString(i) === '')
       t.rows.removeAt(i, 1, false);
   }
   return t;

package/src/utils/parse.ts

@@ -0,0 +1,27 @@
+export const CELL_STRUCTURE = {
+  DUPLEX: {
+    BEFORE_SS: 'SS ',
+    BEFORE_AS: '\r\nAS ',
+  },
+  TRIPLEX_OR_DIMER: {
+    BEFORE_SS: 'SS ',
+    BEFORE_AS1: '\r\nAS1 ',
+    BEFORE_AS2: '\r\nAS2 ',
+  },
+};
+
+export function parseStrandsFromDuplexCell(s: string): { SS: string, AS: string } {
+  const arr = s
+    .slice(CELL_STRUCTURE.DUPLEX.BEFORE_SS.length)
+    .split(CELL_STRUCTURE.DUPLEX.BEFORE_AS);
+  return {SS: arr[0], AS: arr[1]};
+}
+
+export function parseStrandsFromTriplexOrDimerCell(s: string): { SS: string, AS1: string, AS2: string } {
+  const arr1 = s
+    .slice(CELL_STRUCTURE.TRIPLEX_OR_DIMER.BEFORE_SS.length)
+    .split(CELL_STRUCTURE.TRIPLEX_OR_DIMER.BEFORE_AS1);
+  const arr2 = arr1[1]
+    .split(CELL_STRUCTURE.TRIPLEX_OR_DIMER.BEFORE_AS2);
+  return {SS: arr1[0], AS1: arr2[0], AS2: arr2[1]};
+}