@datagrok/sequence-translator 1.0.15 → 1.0.16

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@datagrok/sequence-translator",
   "friendlyName": "Sequence Translator",
-  "version": "1.0.15",
+  "version": "1.0.16",
   "author": {
     "name": "Alexey Choposky",
     "email": "achopovsky@datagrok.ai"
@@ -16,7 +16,7 @@
     "@datagrok-libraries/utils": "^1.17.2",
     "@types/react": "^18.0.15",
     "@datagrok-libraries/bio": "^5.11.1",
-    "datagrok-api": "^1.7.2",
+    "datagrok-api": "^1.8.2",
     "datagrok-tools": "^4.1.2",
     "npm": "^8.11.0",
     "openchemlib": "6.0.1",

package/src/apps/oligo-sd-file-app.ts

@@ -0,0 +1,58 @@
+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 {FileSource} from 'datagrok-api/dg';
+
+export class OligoSdFileApp {
+  df!: DG.DataFrame;
+
+  constructor() {}
+
+  async init(srcDf?: DG.DataFrame): Promise<void> {
+    let dataDf: DG.DataFrame;
+    if (srcDf) {
+      dataDf = srcDf;
+    } else {
+      const dfFn: string = 'System:AppData/SequenceTranslator/test input_Nov28_Duplex_dimer.xlsx';
+      dataDf = await this.loadData(dfFn);
+    }
+
+    this.setData(dataDf);
+  }
+
+  async loadData(dfFn: string): Promise<DG.DataFrame> {
+    //
+    const dataDf: DG.DataFrame = await grok.data.files.openTable(dfFn);
+    return dataDf;
+  }
+
+  async setData(df: DG.DataFrame): Promise<void> {
+    if (this.viewed) {
+      await this.destroyView();
+      this.viewed = false;
+    }
+
+    this.df = df;
+
+    if (!this.viewed) {
+      await this.buildView();
+      this.viewed = true;
+    }
+  }
+
+  private viewed: boolean = false;
+  private tView?: DG.TableView;
+
+  async destroyView(): Promise<void> {
+    this.tView!.close();
+    delete this.tView;
+  }
+
+  async buildView(): Promise<void> {
+    console.debug('SequenceTranslator: OligoSdFileApp.buildView() ');
+
+    this.tView = grok.shell.addTableView(this.df);
+    this.tView.path = this.tView.basePath = 'func/SequenceTranslator.oligoSdFileApp';
+  }
+}

package/src/autostart/calculations.ts

@@ -1,21 +1,24 @@
 import * as DG from 'datagrok-api/dg';
+
 import {sortByStringLengthInDescendingOrder} from '../helpers';
 import {MODIFICATIONS} from '../structures-works/map';
 
 export function saltMass(
-  saltNames: string[], molWeightCol: DG.Column, equivalentsCol: DG.Column, i: number, saltCol: DG.Column,
+  saltNames: string[], saltsMolWeightList: number[], equivalentsCol: DG.Column, i: number, saltCol: DG.Column
 ): number {
   const saltRowIndex = saltNames.indexOf(saltCol.get(i));
   return (
-    saltRowIndex == -1 || molWeightCol.get(saltRowIndex) == DG.FLOAT_NULL || equivalentsCol.get(i) == DG.INT_NULL
+    saltRowIndex == -1 || saltsMolWeightList[saltRowIndex] == DG.FLOAT_NULL || equivalentsCol.get(i) == DG.INT_NULL
   ) ?
     DG.FLOAT_NULL :
-    molWeightCol.get(saltRowIndex) * equivalentsCol.get(i);
+    saltsMolWeightList[saltRowIndex] * equivalentsCol.get(i);
 }
 
-export function saltMolWeigth(saltNamesList: string[], saltCol: DG.Column, molWeightCol: DG.Column, i: number): number {
+export function saltMolWeigth(
+  saltNamesList: string[], saltCol: DG.Column, saltsMolWeightList: number[], i: number
+): number {
   const saltRowIndex = saltNamesList.indexOf(saltCol.get(i));
-  return (saltRowIndex == -1) ? DG.FLOAT_NULL : molWeightCol.get(saltRowIndex);
+  return (saltRowIndex == -1) ? DG.FLOAT_NULL : saltsMolWeightList[saltRowIndex];
 }
 
 export function batchMolWeight(compoundMolWeightCol: DG.Column, saltMassCol: DG.Column, i: number): number {
@@ -24,7 +27,7 @@ export function batchMolWeight(compoundMolWeightCol: DG.Column, saltMassCol: DG.
     compoundMolWeightCol.get(i) + saltMassCol.get(i);
 }
 
-export function molecularWeight(sequence: string, weightsObj: {[index: string]: number}): number {
+export function molecularWeight(sequence: string, weightsObj: { [index: string]: number }): number {
   const codes = sortByStringLengthInDescendingOrder(Object.keys(weightsObj)).concat(Object.keys(MODIFICATIONS));
   let weight = 0;
   let i = 0;

package/src/autostart/constants.ts

@@ -6,18 +6,6 @@ export const SEQUENCE_TYPES = {
   DIMER: 'Dimer',
 };
 
-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 const COL_NAMES = {
   CHEMISTRY: 'Chemistry',
   NUMBER: 'Number',

package/src/autostart/registration.ts

@@ -1,10 +1,12 @@
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
-import {siRnaBioSpringToGcrs, siRnaAxolabsToGcrs, gcrsToNucleotides, asoGapmersBioSpringToGcrs, gcrsToMermade12,
-  siRnaNucleotidesToGcrs} from '../structures-works/converters';
+import {
+  siRnaBioSpringToGcrs, siRnaAxolabsToGcrs, gcrsToNucleotides, asoGapmersBioSpringToGcrs, gcrsToMermade12,
+  siRnaNucleotidesToGcrs
+} from '../structures-works/converters';
 import {weightsObj, SYNTHESIZERS} from '../structures-works/map';
-import {SEQUENCE_TYPES, COL_NAMES, GENERATED_COL_NAMES, CELL_STRUCTURE} from './constants';
+import {SEQUENCE_TYPES, COL_NAMES, GENERATED_COL_NAMES} from './constants';
 import {saltMass, saltMolWeigth, molecularWeight, batchMolWeight} from './calculations';
 import {isValidSequence} from '../structures-works/sequence-codes-tools';
 import {sequenceToMolV3000} from '../structures-works/from-monomers';
@@ -17,109 +19,137 @@ import {ICDS} from './ICDs';
 import {SOURCES} from './sources';
 import {IDPS} from './IDPs';
 
+import {sdfAddColumns} from '../utils/sdf-add-columns';
+import {sdfSaveTable} from '../utils/sdf-save-table';
 
-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]};
+const enum SEQ_TYPE {
+  AS = 'AS',
+  SS = 'SS',
+  DUPLEX = 'Duplex',
+  DIMER = 'Dimer',
 }
 
-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]};
+/** Computable classes of sequence types */
+const enum SEQ_TYPE_CLASS {
+  AS_OR_SS,
+  DUPLEX,
+  DIMER,
 }
 
-async function saveTableAsSdFile(table: DG.DataFrame) {
-  if (GENERATED_COL_NAMES.some((colName) => !table.columns.contains(colName))) {
-    const absentColNames = differenceOfTwoArrays(GENERATED_COL_NAMES, table.columns.names()).join(`', '`);
-    grok.shell.warning(`File saved without columns '${absentColNames}'`);
-  }
+/** Style used for a cell with invalid value  */
+const errorStyle = {
+  'background-color': '#ff8080',
+  'width': '100%',
+  'height': '100%',
+};
+
+export function sdfHandleErrorUI(msgPrefix: string, df: DG.DataFrame, rowI: number, err: any) {
+  const errStr: string = err.toString();
+  const errMsg: string = msgPrefix + `row #${rowI + 1}, name: '${df.get('Chemistry Name', rowI)}', ` +
+    `type: ${df.get('Type', rowI)} error: ${errStr}.`;
+  grok.shell.warning(errMsg);
+}
 
-  const sequenceCol = table.getCol(COL_NAMES.SEQUENCE);
-  const typeCol = table.getCol(COL_NAMES.TYPE);
+// todo: use a dictionary instead?
+function getActualTypeClass(actualType: string): SEQ_TYPE_CLASS {
+  if (actualType === SEQ_TYPE.AS || actualType === SEQ_TYPE.SS)
+    return SEQ_TYPE_CLASS.AS_OR_SS;
+  else if (actualType === SEQ_TYPE.DIMER)
+    return SEQ_TYPE_CLASS.DIMER;
+  else if (actualType === SEQ_TYPE.DUPLEX)
+    return SEQ_TYPE_CLASS.DUPLEX;
+  else
+    throw new Error('Some types in \'Types\' column are invalid ');
+}
 
-  let result = '';
-  for (let i = 0; i < table.rowCount; i++) {
-    const format = SYNTHESIZERS.GCRS; //getFormat(sequenceCol.get(i))!;
-    if (typeCol.get(i) == SEQUENCE_TYPES.SENSE_STRAND)
-      result += `${sequenceToMolV3000(sequenceCol.get(i), false, true, format)}\n> <Sequence>\nSense Strand\n\n`;
-    else if (typeCol.get(i) == SEQUENCE_TYPES.ANTISENSE_STRAND)
-      result += `${sequenceToMolV3000(sequenceCol.get(i), true, true, format)}\n> <Sequence>\nAnti Sense\n\n`;
-    else if (typeCol.get(i) == SEQUENCE_TYPES.DUPLEX) {
-      const obj = parseStrandsFromDuplexCell(sequenceCol.get(i));
-      const as = `${sequenceToMolV3000(obj.AS, true, true, format)}\n> <Sequence>\nAnti Sense\n\n`;
-      const ss = `${sequenceToMolV3000(obj.SS, false, true, format)}\n> <Sequence>\nSense Strand\n\n`;
-      result += `${linkStrandsV3000({senseStrands: [ss], antiStrands: [as]}, true)}\n\n`;
-    } else if ([SEQUENCE_TYPES.TRIPLEX, SEQUENCE_TYPES.DIMER].includes(typeCol.get(i))) {
-      const obj = parseStrandsFromTriplexOrDimerCell(sequenceCol.get(i));
-      const as1 = `${sequenceToMolV3000(obj.AS1, true, true, format)}\n> <Sequence>\nAnti Sense\n\n`;
-      const as2 = `${sequenceToMolV3000(obj.AS2, true, true, format)}\n> <Sequence>\nAnti Sense\n\n`;
-      const ss = `${sequenceToMolV3000(obj.SS, false, true, format)}\n> <Sequence>\nSense Strand\n\n`;
-      result += `${linkStrandsV3000({senseStrands: [ss], antiStrands: [as1, as2]}, true)}\n\n`;
-    }
+function inferTypeClassFromSequence(seq: string): SEQ_TYPE_CLASS {
+  const lines = seq.split('\n');
+  if (lines.length === 1)
+    return SEQ_TYPE_CLASS.AS_OR_SS;
+  else if (lines.length === 2)
+    return SEQ_TYPE_CLASS.DUPLEX;
+  else if (lines.length === 3)
+    return SEQ_TYPE_CLASS.DIMER;
+  else
+    throw new Error('Wrong formatting of sequences in \'Sequence\' column');
+  //todo: throw in the case of wrong formatting
+}
+
+/** Compare type specified in 'Type' column to that computed from 'Sequence' column  */
+function validateType(actualType: string, seq: string): boolean {
+  return getActualTypeClass(actualType) === inferTypeClassFromSequence(seq);
+}
 
-    for (const col of table.columns) {
-      if (col.name != COL_NAMES.SEQUENCE)
-        result += `> <${col.name}>\n${col.get(i)}\n\n`;
+function oligoSdFileGrid(view: DG.TableView): void {
+  const typeColName = 'Type';
+  const seqColName = 'Sequence';
+  const grid = view.grid;
+  const df = view.dataFrame;
+  const typeCol = df.getCol(typeColName);
+  grid.columns.byName(typeColName)!.cellType = 'html';
+  const seqCol = df.getCol(seqColName);
+  grid.onCellPrepare((gridCell: DG.GridCell) => {
+    if (gridCell.isTableCell && gridCell.gridColumn.column!.name === typeColName) {
+      const isValidType = validateType(gridCell.cell.value, seqCol.get(gridCell.tableRow!.idx));
+      gridCell.style.element = ui.div(gridCell.cell.value, isValidType ? {} : {style: errorStyle});
     }
-    result += '$$$$\n';
-  }
-  download(`${table.name}.sdf`, encodeURIComponent(result));
+  });
 }
 
 export function autostartOligoSdFileSubscription() {
   grok.events.onViewAdded.subscribe((v: any) => {
-    if (v.type == DG.VIEW_TYPE.TABLE_VIEW) {
-      if (v.dataFrame.columns.contains(COL_NAMES.TYPE))
+    if (v.type === DG.VIEW_TYPE.TABLE_VIEW) {
+      if (v.dataFrame.columns.contains(COL_NAMES.TYPE)) {
+        oligoSdFileGrid(v);
         oligoSdFile(v.dataFrame);
+      }
 
       // Should be removed after fixing bug https://github.com/datagrok-ai/public/issues/808
       grok.events.onContextMenu.subscribe((args) => {
-        const seqCol = args.args.context.table.currentCol; // /^[fsACGUacgu]{6,}$/
+        if (!(args.args.context instanceof DG.Grid)) return;
+        const grid: DG.Grid = args.args.context as DG.Grid;
+        const menu: DG.Menu = args.args.menu;
+
+        const seqCol = grid.table.currentCol; // /^[fsACGUacgu]{6,}$/
         if (DG.Detector.sampleCategories(seqCol,
           (s) => /(\(invabasic\)|\(GalNAc-2-JNJ\)|A|U|G|C){6,}$/.test(s))) {
-          args.args.menu.item('Convert raw nucleotides to GCRS', () => {
-            args.args.context.table.columns.addNewString(seqCol.name + ' to GCRS').init((i: number) => {
+          menu.item('Convert raw nucleotides to GCRS', () => {
+            grid.table.columns.addNewString(seqCol.name + ' to GCRS').init((i: number) => {
               return siRnaNucleotidesToGcrs(seqCol.get(i));
             });
           });
         } else if (DG.Detector.sampleCategories(seqCol,
           (s) => /(\(invabasic\)|\(GalNAc-2-JNJ\)|f|s|A|C|G|U|a|c|g|u){6,}$/.test(s))) {
-          args.args.menu.item('Convert Axolabs to GCRS', () => {
-            args.args.context.table.columns.addNewString(seqCol.name + ' to GCRS').init((i: number) => {
+          menu.item('Convert Axolabs to GCRS', () => {
+            grid.table.columns.addNewString(seqCol.name + ' to GCRS').init((i: number) => {
               return siRnaAxolabsToGcrs(seqCol.get(i));
             });
           }); // /^[fmpsACGU]{6,}$/
         } else if (DG.Detector.sampleCategories(seqCol,
-          (s) => /(\(invabasic\)|\(GalNAc-2-JNJ\)|f|m|ps|A|C|G|U){6,}$/.test(s)) ||
-        DG.Detector.sampleCategories(seqCol, (s) => /^(?=.*moe)(?=.*5mC)(?=.*ps){6,}/.test(s))) {
-          args.args.menu.item('Convert GCRS to raw', () => {
-            args.args.context.table.columns.addNewString(seqCol.name + ' to raw').init((i: number) => {
+            (s) => /(\(invabasic\)|\(GalNAc-2-JNJ\)|f|m|ps|A|C|G|U){6,}$/.test(s)) ||
+          DG.Detector.sampleCategories(seqCol, (s) => /^(?=.*moe)(?=.*5mC)(?=.*ps){6,}/.test(s))) {
+          menu.item('Convert GCRS to raw', () => {
+            grid.table.columns.addNewString(seqCol.name + ' to raw').init((i: number) => {
               return gcrsToNucleotides(seqCol.get(i));
             });
           });
-          args.args.menu.item('Convert GCRS to MM12', () => {
-            args.args.context.table.columns.addNewString(seqCol.name + ' to MM12').init((i: number) => {
+          menu.item('Convert GCRS to MM12', () => {
+            grid.table.columns.addNewString(seqCol.name + ' to MM12').init((i: number) => {
               return gcrsToMermade12(seqCol.get(i));
             });
           }); // /^[*56789ATGC]{6,}$/
         } else if (DG.Detector.sampleCategories(seqCol,
           (s) => /(\(invabasic\)|\(GalNAc-2-JNJ\)|\*|5|6|7|8|9|A|T|G|C){6,}$/.test(s))) {
-          args.args.menu.item('Convert Biospring to GCRS', () => {
-            const seqCol = args.args.context.table.currentCol;
-            args.args.context.table.columns.addNewString(seqCol.name + ' to GCRS').init((i: number) => {
+          menu.item('Convert Biospring to GCRS', () => {
+            const seqCol = grid.table.currentCol;
+            grid.table.columns.addNewString(seqCol.name + ' to GCRS').init((i: number) => {
               return asoGapmersBioSpringToGcrs(seqCol.get(i));
             });
           }); // /^[*1-8]{6,}$/
         } else if (DG.Detector.sampleCategories(seqCol,
           (s) => /(\(invabasic\)|\(GalNAc-2-JNJ\)|\*|1|2|3|4|5|6|7|8){6,}$/.test(s))) {
-          args.args.menu.item('Convert Biospring to GCRS', () => {
-            args.args.context.table.columns.addNewString(seqCol.name + ' to GCRS').init((i: number) => {
+          menu.item('Convert Biospring to GCRS', () => {
+            grid.table.columns.addNewString(seqCol.name + ' to GCRS').init((i: number) => {
               return siRnaBioSpringToGcrs(seqCol.get(i));
             });
           });
@@ -136,85 +166,13 @@ export function oligoSdFile(table: DG.DataFrame) {
   const icdsDf = DG.DataFrame.fromCsv(ICDS);
   const idpsDf = DG.DataFrame.fromCsv(IDPS);
 
-  const sequenceCol = table.getCol(COL_NAMES.SEQUENCE);
   const saltCol = table.getCol(COL_NAMES.SALT);
   const equivalentsCol = table.getCol(COL_NAMES.EQUIVALENTS);
-  const typeCol = table.getCol(COL_NAMES.TYPE);
-  const chemistryNameCol = table.getCol(COL_NAMES.CHEMISTRY_NAME);
-
-  const molWeightCol = saltsDf.getCol('MOLWEIGHT');
-  const saltNamesList = saltsDf.getCol('DISPLAY').toList();
-
-  let newDf: DG.DataFrame;
-  let addColumnsPressed = false;
 
-  function addColumns(t: DG.DataFrame) {
-    if (GENERATED_COL_NAMES.some((colName) => t.columns.contains(colName)))
-      return grok.shell.error('Columns already exist');
+  const saltsMolWeightList: number[] = saltsDf.getCol('MOLWEIGHT').toList();
+  const saltNamesList: string[] = saltsDf.getCol('DISPLAY').toList();
 
-    t = removeEmptyRows(t, sequenceCol);
-
-    t.columns.addNewString(COL_NAMES.COMPOUND_NAME).init((i: number) => {
-      return ([SEQUENCE_TYPES.DUPLEX, SEQUENCE_TYPES.DIMER, SEQUENCE_TYPES.TRIPLEX].includes(typeCol.get(i))) ?
-        chemistryNameCol.get(i) :
-        sequenceCol.get(i);
-    });
-
-    t.columns.addNewString(COL_NAMES.COMPOUND_COMMENTS).init((i: number) => {
-      if ([SEQUENCE_TYPES.SENSE_STRAND, SEQUENCE_TYPES.ANTISENSE_STRAND].includes(typeCol.get(i)))
-        return sequenceCol.get(i);
-      else if (typeCol.get(i) == SEQUENCE_TYPES.DUPLEX) {
-        const obj = parseStrandsFromDuplexCell(sequenceCol.get(i));
-        return `${chemistryNameCol.get(i)}; duplex of SS: ${obj.SS} and AS: ${obj.AS}`;
-      } else if ([SEQUENCE_TYPES.DIMER, SEQUENCE_TYPES.TRIPLEX].includes(typeCol.get(i))) {
-        const obj = parseStrandsFromTriplexOrDimerCell(sequenceCol.get(i));
-        return `${chemistryNameCol.get(i)}; duplex of SS: ${obj.SS} and AS1: ${obj.AS1} and AS2: ${obj.AS2}`;
-      }
-    });
-
-    t.columns.addNewFloat(COL_NAMES.COMPOUND_MOL_WEIGHT).init((i: number) => {
-      if ([SEQUENCE_TYPES.SENSE_STRAND, SEQUENCE_TYPES.ANTISENSE_STRAND].includes(typeCol.get(i))) {
-        return (isValidSequence(sequenceCol.get(i), null).indexOfFirstNotValidChar == -1) ?
-          molecularWeight(sequenceCol.get(i), weightsObj) :
-          DG.FLOAT_NULL;
-      } else if (typeCol.get(i) == SEQUENCE_TYPES.DUPLEX) {
-        const obj = parseStrandsFromDuplexCell(sequenceCol.get(i));
-        return (Object.values(obj).every((seq) => isValidSequence(seq, null).indexOfFirstNotValidChar == -1)) ?
-          molecularWeight(obj.SS, weightsObj) + molecularWeight(obj.AS, weightsObj) :
-          DG.FLOAT_NULL;
-      } else if ([SEQUENCE_TYPES.DIMER, SEQUENCE_TYPES.TRIPLEX].includes(typeCol.get(i))) {
-        const obj = parseStrandsFromTriplexOrDimerCell(sequenceCol.get(i));
-        return (Object.values(obj).every((seq) => isValidSequence(seq, null).indexOfFirstNotValidChar == -1)) ?
-          molecularWeight(obj.SS, weightsObj) + molecularWeight(obj.AS1, weightsObj) +
-          molecularWeight(obj.AS2, weightsObj) :
-          DG.FLOAT_NULL;
-      }
-    });
-
-    t.columns.addNewFloat(COL_NAMES.SALT_MASS).init((i: number) =>
-      saltMass(saltNamesList, molWeightCol, equivalentsCol, i, saltCol));
-
-    t.columns.addNewFloat(COL_NAMES.SALT_MOL_WEIGHT).init((i: number) =>
-      saltMolWeigth(saltNamesList, saltCol, molWeightCol, i));
-
-    const compoundMolWeightCol = t.getCol(COL_NAMES.COMPOUND_MOL_WEIGHT);
-    const saltMassCol = t.getCol(COL_NAMES.SALT_MASS);
-    t.columns.addNewFloat(COL_NAMES.BATCH_MOL_WEIGHT).init((i: number) =>
-      batchMolWeight(compoundMolWeightCol, saltMassCol, i));
-
-    grok.shell.getTableView(table.name).grid.columns.setOrder(Object.values(COL_NAMES));
-    addColumnsPressed = true;
-    return newDf = t;
-  }
-
-  function updateCalculatedColumns(t: DG.DataFrame, i: number): void {
-    const smValue = saltMass(saltNamesList, molWeightCol, equivalentsCol, i, saltCol);
-    t.getCol(COL_NAMES.SALT_MASS).set(i, smValue, false);
-    const smwValue = saltMolWeigth(saltNamesList, saltCol, molWeightCol, i);
-    t.getCol(COL_NAMES.SALT_MOL_WEIGHT).set(i, smwValue, false);
-    const bmw = batchMolWeight(t.getCol(COL_NAMES.COMPOUND_MOL_WEIGHT), t.getCol(COL_NAMES.SALT_MASS), i);
-    t.getCol(COL_NAMES.BATCH_MOL_WEIGHT).set(i, bmw, false);
-  }
+  let newDf: DG.DataFrame | undefined = undefined;
 
   const d = ui.div([
     ui.icons.edit(() => {
@@ -223,9 +181,19 @@ export function oligoSdFile(table: DG.DataFrame) {
         table.changeColumnType(COL_NAMES.IDP, DG.COLUMN_TYPE.STRING);
       d.append(
         ui.divH([
-          ui.icons.add(() => addColumns(table), `Add columns: '${GENERATED_COL_NAMES.join(`', '`)}'`),
-          ui.icons.save(() => saveTableAsSdFile(addColumnsPressed ? newDf : table), 'Save SD file'),
-        ]),
+          ui.button('Add columns',
+            () => {
+              newDf = sdfAddColumns(table, saltNamesList, saltsMolWeightList,
+                (rowI, err) => { sdfHandleErrorUI('Error on ', table, rowI, err); });
+              grok.shell.getTableView(newDf.name).grid.columns.setOrder(Object.values(COL_NAMES));
+            },
+            `Add columns: '${GENERATED_COL_NAMES.join(`', '`)}'`),
+          ui.bigButton('Save SDF', () => {
+            const df: DG.DataFrame = newDf ?? table;
+            sdfSaveTable(df,
+              (rowI, err) => { sdfHandleErrorUI('Skip ', df, rowI, err); });
+          }, 'Save SD file'),
+        ])
       );
 
       const view = grok.shell.getTableView(table.name);
@@ -238,11 +206,15 @@ export function oligoSdFile(table: DG.DataFrame) {
       view.dataFrame.getCol(COL_NAMES.IDP).setTag(DG.TAGS.CHOICES, stringify(idpsDf.columns.byIndex(0).toList()));
 
       grok.events.onContextMenu.subscribe((args) => {
+        if (!(args.args.context instanceof DG.Grid)) return;
+        const grid: DG.Grid = args.args.context as DG.Grid;
+        const menu: DG.Menu = args.args.menu;
+
         if ([COL_NAMES.TYPE, COL_NAMES.OWNER, COL_NAMES.SALT, COL_NAMES.SOURCE, COL_NAMES.ICD, COL_NAMES.IDP]
-          .includes(args.args.context.table.currentCol.name)) {
-          args.args.menu.item('Fill Column With Value', () => {
-            const v = args.args.context.table.currentCell.value;
-            args.args.context.table.currentCell.column.init(v);
+          .includes(grid.table.currentCol.name)) {
+          menu.item('Fill Column With Value', () => {
+            const v = grid.table.currentCell.value;
+            grid.table.currentCell.column.init(v);
             for (let i = 0; i < view.dataFrame.rowCount; i++)
               updateCalculatedColumns(view.dataFrame, i);
           });
@@ -256,9 +228,9 @@ export function oligoSdFile(table: DG.DataFrame) {
       });
 
       function updateCalculatedColumns(t: DG.DataFrame, i: number): void {
-        const smValue = saltMass(saltNamesList, molWeightCol, equivalentsCol, i, saltCol);
+        const smValue = saltMass(saltNamesList, saltsMolWeightList, equivalentsCol, i, saltCol);
         t.getCol(COL_NAMES.SALT_MASS).set(i, smValue, false);
-        const smwValue = saltMolWeigth(saltNamesList, saltCol, molWeightCol, i);
+        const smwValue = saltMolWeigth(saltNamesList, saltCol, saltsMolWeightList, i);
         t.getCol(COL_NAMES.SALT_MOL_WEIGHT).set(i, smwValue, false);
         const bmw = batchMolWeight(t.getCol(COL_NAMES.COMPOUND_MOL_WEIGHT), t.getCol(COL_NAMES.SALT_MASS), i);
         t.getCol(COL_NAMES.BATCH_MOL_WEIGHT).set(i, bmw, false);

package/src/main/main-view.ts

@@ -16,14 +16,13 @@ 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 mainView(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 = '';
     outputTableDiv.innerHTML = '';
     const pi = DG.TaskBarProgressIndicator.create('Rendering table and molecule...');
-    let errorsExist = false;
 
     try {
       sequence = sequence.replace(/\s/g, '');
@@ -102,7 +101,7 @@ export async function mainView(): Promise<HTMLDivElement> {
             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}
+              options: {normalizeDepiction: false, straightenDepiction: false}
             });
 
             addDiv.appendChild(dlgCanvas);
@@ -123,7 +122,7 @@ export async function mainView(): Promise<HTMLDivElement> {
         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}
+          options: {normalizeDepiction: false, straightenDepiction: false}
         });
         moleculeSvgDiv.append(formCanvas);
       } else
@@ -146,6 +145,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(

package/src/package.ts

@@ -6,6 +6,7 @@ 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';
+import {OligoSdFileApp} from './apps/oligo-sd-file-app';
 
 export const _package = new DG.Package();
 
@@ -35,14 +36,60 @@ export async function sequenceTranslator(): Promise<void> {
   windows.showToolbox = false;
   windows.showHelp = false;
 
+  let urlParams: URLSearchParams = new URLSearchParams(window.location.search);
+  let mainSeq: string = 'fAmCmGmAmCpsmU';
   const v = grok.shell.newView('Sequence Translator', []);
   v.box = true;
-  v.append(ui.tabControl({
-    'MAIN': await mainView(),
+  const tc = ui.tabControl({
+    'MAIN': await mainView((seq) => {
+      mainSeq = seq;
+      urlParams = new URLSearchParams();
+      urlParams.set('seq', mainSeq);
+      updatePath();
+    }),
     'AXOLABS': defineAxolabsPattern(),
     'SDF': saveSenseAntiSense(),
-  }));
+  });
+  tc.onTabChanged.subscribe((value) => {
+    if (tc.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('&');
+    v.path = '/apps/SequenceTranslator/SequenceTranslator' + `/${tc.currentPane.name}/?${urlParamsTxt}`;
+  }
+
+  const pathParts: string[] = window.location.pathname.split('/');
+  if (pathParts.length >= 5) {
+    const tabName: string = pathParts[5];
+    tc.currentPane = tc.getPane(tabName);
+  }
+
+  v.append(tc);
+  console.debug('SequenceTranslator: app sequenceTranslator() ' + `v.path='${v.path}', v.basePath='${v.basePath}'.`);
 }
 
 //tags: autostart
 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/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]};
+}