@datagrok/sequence-translator 1.0.16 → 1.1.0

package/src/structures-works/save-sense-antisense.ts

@@ -1,91 +0,0 @@
-import * as grok from 'datagrok-api/grok';
-import * as ui from 'datagrok-api/ui';
-import * as DG from 'datagrok-api/dg';
-
-import {download} from '../helpers';
-import {sequenceToMolV3000} from '../structures-works/from-monomers';
-import {linkStrandsV3000} from '../structures-works/mol-transformations';
-import {getFormat} from '../structures-works/sequence-codes-tools';
-
-export function saveSdf(as: string, ss: string,
-                        oneEntity: boolean, useChirality: boolean,
-                        invertSS: boolean, invertAS: boolean,
-                        as2: string | null = null, invertAS2: boolean | null) {
-  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}, useChirality) + '\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`;
-  }
-  download(ss.replace(/\s/g, '') + '.sdf', encodeURIComponent(result));
-}
-
-export function saveSenseAntiSense() {
-  const moleculeSvgDiv = ui.block([]);
-  const ssInput = ui.textInput('Sense Strand', '');
-  const asInput = ui.textInput('Anti Sense', '');
-  const asInput2 = ui.textInput('Anti Sense 2', '');
-  const straight = "5 prime -> 3 prime";
-  const inverse = "3 prime -> 5 prime";
-  let ssInverse = false;
-  let asInverse = false;
-  let as2Inverse = false;
-
-  const changeSense = ui.choiceInput('SS direction', straight, [straight, inverse]);
-  changeSense.onChanged(() => {ssInverse = changeSense.value == inverse;});
-  const changeAntiSense = ui.choiceInput('AS direction', straight, [straight, inverse]);
-  changeAntiSense.onChanged(() => {asInverse = changeAntiSense.value == inverse;});
-  const changeAntiSense2 = ui.choiceInput('AS 2 direction', straight, [straight, inverse]);
-  changeAntiSense2.onChanged(() => {asInverse = changeAntiSense.value == inverse;});
-
-  const saveOption = ui.switchInput('Save as one entity', true);
-  const chirality = ui.switchInput('Use chiral', true);
-  const saveBtn = ui.button('Save SDF', () =>
-    saveSdf(asInput.value, ssInput.value, saveOption.value, chirality.value, ssInverse, asInverse, asInput2.value, as2Inverse));
-
-  const saveSection = ui.panel([
-    ui.div([
-      ui.div([
-        ui.divH([ui.h1('Inputs')]),
-        ui.divV([
-          ssInput,
-          asInput,
-          asInput2,
-          ui.div([changeSense], {style: {width: '40'}}),
-          changeSense,
-          changeAntiSense,
-          changeAntiSense2,
-          saveOption,
-          chirality,
-          ui.buttonsInput([saveBtn]),
-        ], 'ui-form'),
-      ], 'ui-form'),
-    ], 'ui-form'),
-    moleculeSvgDiv,
-  ]);
-
-  return saveSection;
-}

package/src/structures-works/sequence-codes-tools.ts

@@ -1,344 +0,0 @@
-
-import {map, SYNTHESIZERS, TECHNOLOGIES, MODIFICATIONS, DELIMITER, gcrsCodesWithoutSmiles, NUCLEOTIDES} from './map';
-import {sortByStringLengthInDescendingOrder} from '../helpers';
-import {asoGapmersNucleotidesToBioSpring, asoGapmersNucleotidesToGcrs,
-  asoGapmersBioSpringToNucleotides, asoGapmersBioSpringToGcrs, gcrsToMermade12, siRnaNucleotideToBioSpringSenseStrand,
-  siRnaNucleotideToAxolabsSenseStrand, siRnaNucleotidesToGcrs, siRnaBioSpringToNucleotides,
-  siRnaBioSpringToAxolabs, siRnaBioSpringToGcrs, siRnaAxolabsToNucleotides,
-  siRnaAxolabsToBioSpring, siRnaAxolabsToGcrs, siRnaGcrsToNucleotides,
-  siRnaGcrsToBioSpring, siRnaGcrsToAxolabs, gcrsToNucleotides, gcrsToLcms} from './converters';
-
-const noTranslationTableAvailable = 'No translation table available';
-export const undefinedInputSequence = 'Type of input sequence is undefined';
-
-export function getFormat(sequence: string): string | null {
-  const possibleSynthesizers = getListOfPossibleSynthesizersByFirstMatchedCode(sequence);
-
-  if (possibleSynthesizers.length == 0)
-    return null;
-
-  let outputIndex = 0;
-
-  const firstUniqueCharacters = ['r', 'd'];
-
-  possibleSynthesizers.forEach((synthesizer) => {
-    const codes = getAllCodesOfSynthesizer(synthesizer);
-    while (outputIndex < sequence.length) {
-      const matchedCode = codes.find((c) => c == sequence.slice(outputIndex, outputIndex + c.length));
-
-      if (matchedCode == null)
-        break;
-
-      if ( // for mistake pattern 'rAA'
-        outputIndex > 1 &&
-        NUCLEOTIDES.includes(sequence[outputIndex]) &&
-        firstUniqueCharacters.includes(sequence[outputIndex - 2])
-      ) break;
-
-      if ( // for mistake pattern 'ArA'
-        firstUniqueCharacters.includes(sequence[outputIndex + 1]) &&
-        NUCLEOTIDES.includes(sequence[outputIndex])
-      ) {
-        outputIndex++;
-        break;
-      }
-
-      outputIndex += matchedCode.length;
-    }
-  });
-
-  const indexOfFirstNotValidChar = (outputIndex == sequence.length) ? -1 : outputIndex;
-  if (indexOfFirstNotValidChar != -1)
-    return possibleSynthesizers[0];
-
-  const possibleTechnologies = getListOfPossibleTechnologiesByFirstMatchedCode(sequence, possibleSynthesizers[0]);
-
-  if (possibleTechnologies.length == 0)
-    return null;
-
-  outputIndex = 0;
-
-  possibleTechnologies.forEach((technology: string) => {
-    const codes = Object.keys(map[possibleSynthesizers[0]][technology]);
-    while (outputIndex < sequence.length) {
-      const matchedCode = codes.find((c) => c == sequence.slice(outputIndex, outputIndex + c.length));
-
-      if (matchedCode == null)
-        break;
-
-      if ( // for mistake pattern 'rAA'
-        outputIndex > 1 &&
-        NUCLEOTIDES.includes(sequence[outputIndex]) &&
-        firstUniqueCharacters.includes(sequence[outputIndex - 2])
-      ) break;
-
-      if ( // for mistake pattern 'ArA'
-        firstUniqueCharacters.includes(sequence[outputIndex + 1]) &&
-        NUCLEOTIDES.includes(sequence[outputIndex])
-      ) {
-        outputIndex++;
-        break;
-      }
-
-      outputIndex += matchedCode.length;
-    }
-  });
-
-  return possibleSynthesizers[0];
-}
-
-
-export function isValidSequence(sequence: string, format: string | null): {
-  indexOfFirstNotValidChar: number,
-  synthesizer: string[] | null,
-  // technology: string[] | null
-} {
-  const possibleSynthesizers = format == null ?
-    getListOfPossibleSynthesizersByFirstMatchedCode(sequence) :
-    [format];
-
-  // if (possibleSynthesizers.length > 1) {
-  //   const synthesizer = ui.choiceInput('Choose synthesizer from list: ', possibleSynthesizers[0],
-  //  possibleSynthesizers);
-  //   ui.dialog('Choose Synthesizer')
-  //     .add(ui.panel([synthesizer.root], {style: {fontWeight: 'bold'}}))
-  //     .onOK(() => possibleSynthesizers = [synthesizer.value])
-  //     .onCancel(() => {
-  //       possibleSynthesizers = [possibleSynthesizers[0]];
-  //       grok.shell.warning('Input sequence is expected to be in format ' + possibleSynthesizers[0]);
-  //     })
-  //     .show();
-  // } else if (possibleSynthesizers.length == 0)
-  if (possibleSynthesizers.length == 0)
-    return {indexOfFirstNotValidChar: 0, synthesizer: null};//, technology: null};
-
-  const outputIndices = Array(possibleSynthesizers.length).fill(0);
-
-  const firstUniqueCharacters = ['r', 'd'];
-  possibleSynthesizers.forEach(function(synthesizer, i) {
-    const codes = sortByStringLengthInDescendingOrder(getAllCodesOfSynthesizer(synthesizer));
-    while (outputIndices[i] < sequence.length) {
-      const matchedCode = codes.find((c) => c == sequence.slice(outputIndices[i], outputIndices[i] + c.length));
-
-      if (matchedCode == null)
-        break;
-
-      if ( // for mistake pattern 'rAA'
-        outputIndices[i] > 1 &&
-        NUCLEOTIDES.includes(sequence[outputIndices[i]]) &&
-        firstUniqueCharacters.includes(sequence[outputIndices[i] - 2])
-      ) break;
-
-      if ( // for mistake pattern 'ArA'
-        firstUniqueCharacters.includes(sequence[outputIndices[i] + 1]) &&
-        NUCLEOTIDES.includes(sequence[outputIndices[i]])
-      ) {
-        outputIndices[i]++;
-        break;
-      }
-
-      outputIndices[i] += matchedCode.length;
-    }
-  });
-
-  const outputIndex = Math.max(...outputIndices);
-  const synthesizer = possibleSynthesizers[outputIndices.indexOf(outputIndex)];
-  const indexOfFirstNotValidChar = (outputIndex == sequence.length) ? -1 : outputIndex;
-  if (indexOfFirstNotValidChar != -1) {
-    return {
-      indexOfFirstNotValidChar: indexOfFirstNotValidChar,
-      synthesizer: [synthesizer],
-      // technology: null,
-    };
-  }
-
-  // const possibleTechnologies =
-  //   getListOfPossibleTechnologiesByFirstMatchedCode(sequence, possibleSynthesizers[outputIndex]);
-
-  // if (possibleTechnologies.length > 1) {
-  //   const technology = ui.choiceInput('Choose technology from list: ', possibleTechnologies[0],
-  // possibleTechnologies);
-  //   ui.dialog('Choose Technology')
-  //     .add(ui.panel([technology.root], {style: {fontWeight: 'bold'}}))
-  //     .onOK(() => possibleTechnologies = [technology.value])
-  //     .onCancel(() => {
-  //       possibleTechnologies = [possibleTechnologies[0]];
-  //       grok.shell.warning('Input sequence is expected to be in format ' + possibleTechnologies[0]);
-  //     })
-  //     .show();
-  // } else if (possibleTechnologies.length == 0)
-  // if (possibleTechnologies.length == 0)
-  //   return {indexOfFirstNotValidChar: 0, synthesizer: [possibleSynthesizers[3]], technology: null};
-
-  // outputIndex = 0;
-
-  // possibleTechnologies.forEach((technology: string) => {
-  //   const codes = Object.keys(map[possibleSynthesizers[0]][technology]);
-  //   while (outputIndex < sequence.length) {
-  //     const matchedCode = codes.find((c) => c == sequence.slice(outputIndex, outputIndex + c.length));
-
-  //     if (matchedCode == null)
-  //       break;
-
-  //     if ( // for mistake pattern 'rAA'
-  //       outputIndex > 1 &&
-  //       nucleotides.includes(sequence[outputIndex]) &&
-  //       firstUniqueCharacters.includes(sequence[outputIndex - 2])
-  //     ) break;
-
-  //     if ( // for mistake pattern 'ArA'
-  //       firstUniqueCharacters.includes(sequence[outputIndex + 1]) &&
-  //       nucleotides.includes(sequence[outputIndex])
-  //     ) {
-  //       outputIndex++;
-  //       break;
-  //     }
-
-  //     outputIndex += matchedCode.length;
-  //   }
-  // });
-
-  return {
-    indexOfFirstNotValidChar: indexOfFirstNotValidChar,
-    synthesizer: [synthesizer],
-    // technology: [possibleTechnologies[0]],
-  };
-}
-
-export function getAllCodesOfSynthesizer(synthesizer: string): string[] {
-  let codes: string[] = [];
-  for (const technology of Object.keys(map[synthesizer]))
-    codes = codes.concat(Object.keys(map[synthesizer][technology]));
-  return codes.concat(Object.keys(MODIFICATIONS)).concat(DELIMITER);
-}
-
-function getListOfPossibleSynthesizersByFirstMatchedCode(sequence: string): string[] {
-  let synthesizers: string[] = [];
-  Object.keys(map).forEach((synthesizer: string) => {
-    let codes = sortByStringLengthInDescendingOrder(getAllCodesOfSynthesizer(synthesizer));
-    if (synthesizer == 'Janssen GCRS Codes')
-      codes = codes.concat(gcrsCodesWithoutSmiles);
-    //TODO: get first non-dropdown code when there are two modifications
-    let start = 0;
-    for (let i = 0; i < sequence.length; i++) {
-      if (sequence[i] == ')' && i != sequence.length - 1) {
-        start = i + 1;
-        break;
-      }
-    }
-    if (gcrsCodesWithoutSmiles.some((s: string) => s == sequence.slice(start, start + s.length)))
-      synthesizers = ['Janssen GCRS Codes'];
-    if (codes.some((s: string) => s == sequence.slice(start, start + s.length)))
-      synthesizers.push(synthesizer);
-  });
-  return synthesizers;
-}
-
-function getListOfPossibleTechnologiesByFirstMatchedCode(sequence: string, synthesizer: string): string[] {
-  const technologies: string[] = [];
-  Object.keys(map[synthesizer]).forEach((technology: string) => {
-    const codes = Object.keys(map[synthesizer][technology]).concat(Object.keys(MODIFICATIONS));
-    if (codes.some((s) => s == sequence.slice(0, s.length)))
-      technologies.push(technology);
-  });
-  return technologies;
-}
-
-export function convertSequence(sequence: string, output: {
-  indexOfFirstNotValidChar: number, synthesizer: string[] | null}) {//, technology: string[] | null}) {
-  if (output.indexOfFirstNotValidChar != -1) {
-    return {
-      // type: '',
-      indexOfFirstNotValidChar: JSON.stringify(output),
-      Error: undefinedInputSequence,
-    };
-  }
-  if (output.synthesizer!.includes(SYNTHESIZERS.RAW_NUCLEOTIDES)) {//&& output.technology!.includes(TECHNOLOGIES.DNA)) {
-    return {
-      type: SYNTHESIZERS.RAW_NUCLEOTIDES, // + ' ' + TECHNOLOGIES.DNA,
-      Nucleotides: sequence,
-      BioSpring: asoGapmersNucleotidesToBioSpring(sequence),
-      GCRS: asoGapmersNucleotidesToGcrs(sequence),
-    };
-  }
-  if (output.synthesizer!.includes(SYNTHESIZERS.BIOSPRING)) {
-    // && output.technology!.includes(TECHNOLOGIES.ASO_GAPMERS)) {
-    return {
-      type: SYNTHESIZERS.BIOSPRING + ' ' + TECHNOLOGIES.ASO_GAPMERS,
-      Nucleotides: asoGapmersBioSpringToNucleotides(sequence),
-      BioSpring: sequence,
-      GCRS: asoGapmersBioSpringToGcrs(sequence),
-    };
-  }
-  if (output.synthesizer!.includes(SYNTHESIZERS.GCRS)) { // && output.technology!.includes(TECHNOLOGIES.ASO_GAPMERS)) {
-    return {
-      type: SYNTHESIZERS.GCRS + ' ' + TECHNOLOGIES.ASO_GAPMERS,
-      Nucleotides: gcrsToNucleotides(sequence),
-      BioSpring: siRnaGcrsToBioSpring(sequence),
-      Axolabs: siRnaGcrsToAxolabs(sequence),
-      Mermade12: gcrsToMermade12(sequence),
-      GCRS: sequence,
-      LCMS: gcrsToLcms(sequence),
-    };
-  }
-  if (output.synthesizer!.includes(SYNTHESIZERS.RAW_NUCLEOTIDES)) {
-    // && output.technology!.includes(TECHNOLOGIES.RNA)) {
-    return {
-      type: SYNTHESIZERS.RAW_NUCLEOTIDES + ' ' + TECHNOLOGIES.RNA,
-      Nucleotides: sequence,
-      BioSpring: siRnaNucleotideToBioSpringSenseStrand(sequence),
-      Axolabs: siRnaNucleotideToAxolabsSenseStrand(sequence),
-      GCRS: siRnaNucleotidesToGcrs(sequence),
-    };
-  }
-  if (output.synthesizer!.includes(SYNTHESIZERS.BIOSPRING)) { // && output.technology!.includes(TECHNOLOGIES.SI_RNA)) {
-    return {
-      type: SYNTHESIZERS.BIOSPRING + ' ' + TECHNOLOGIES.SI_RNA,
-      Nucleotides: siRnaBioSpringToNucleotides(sequence),
-      BioSpring: sequence,
-      Axolabs: siRnaBioSpringToAxolabs(sequence),
-      GCRS: siRnaBioSpringToGcrs(sequence),
-    };
-  }
-  if (output.synthesizer!.includes(SYNTHESIZERS.AXOLABS)) {
-    return {
-      type: SYNTHESIZERS.AXOLABS + ' ' + TECHNOLOGIES.SI_RNA,
-      Nucleotides: siRnaAxolabsToNucleotides(sequence),
-      BioSpring: siRnaAxolabsToBioSpring(sequence),
-      Axolabs: sequence,
-      GCRS: siRnaAxolabsToGcrs(sequence),
-    };
-  }
-  if (output.synthesizer!.includes(SYNTHESIZERS.GCRS)) { // && output.technology!.includes(TECHNOLOGIES.SI_RNA)) {
-    return {
-      type: SYNTHESIZERS.GCRS + ' ' + TECHNOLOGIES.SI_RNA,
-      Nucleotides: siRnaGcrsToNucleotides(sequence),
-      BioSpring: siRnaGcrsToBioSpring(sequence),
-      Axolabs: siRnaGcrsToAxolabs(sequence),
-      MM12: gcrsToMermade12(sequence),
-      GCRS: sequence,
-      LCMS: gcrsToLcms(sequence),
-    };
-  }
-  if (output.synthesizer!.includes(SYNTHESIZERS.GCRS)) {
-    return {
-      type: SYNTHESIZERS.GCRS,
-      Nucleotides: gcrsToNucleotides(sequence),
-      GCRS: sequence,
-      Mermade12: gcrsToMermade12(sequence),
-      LCMS: gcrsToLcms(sequence),
-    };
-  }
-  if (output.synthesizer!.includes(SYNTHESIZERS.MERMADE_12)) {
-    return {
-      type: SYNTHESIZERS.MERMADE_12,
-      Nucleotides: noTranslationTableAvailable,
-      GCRS: noTranslationTableAvailable,
-      Mermade12: sequence,
-    };
-  }
-  return {
-    type: undefinedInputSequence,
-    Nucleotides: undefinedInputSequence,
-  };
-}

package/src/utils/parse.ts

@@ -1,27 +0,0 @@
-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]};
-}

package/src/utils/sdf-add-columns.ts

@@ -1,118 +0,0 @@
-import * as DG from 'datagrok-api/dg';
-import {COL_NAMES, GENERATED_COL_NAMES, SEQUENCE_TYPES} from '../autostart/constants';
-import * as grok from 'datagrok-api/grok';
-import {removeEmptyRows} from '../helpers';
-import {parseStrandsFromDuplexCell, parseStrandsFromTriplexOrDimerCell} from './parse';
-import {isValidSequence} from '../structures-works/sequence-codes-tools';
-import {batchMolWeight, molecularWeight, saltMass, saltMolWeigth} from '../autostart/calculations';
-import {weightsObj} from '../structures-works/map';
-
-export class SdfColumnsExistsError extends Error {
-  constructor(message: string) {
-    super();
-  }
-}
-
-export function sdfAddColumns(
-  df: DG.DataFrame, saltNamesList: string[], saltsMolWeightList: number[], onError: (rowI: number, err: any) => void
-): DG.DataFrame {
-  const sequenceCol = df.getCol(COL_NAMES.SEQUENCE);
-  const saltCol = df.getCol(COL_NAMES.SALT);
-  const equivalentsCol = df.getCol(COL_NAMES.EQUIVALENTS);
-  const typeCol = df.getCol(COL_NAMES.TYPE);
-  const chemistryNameCol = df.getCol(COL_NAMES.CHEMISTRY_NAME);
-
-  if (GENERATED_COL_NAMES.some((colName) => df.columns.contains(colName)))
-    throw new SdfColumnsExistsError('Columns already exist');
-
-  df = removeEmptyRows(df, sequenceCol);
-
-  df.columns.addNewString(COL_NAMES.COMPOUND_NAME).init((i: number) => {
-    let res: string = '';
-    try {
-      res = ([SEQUENCE_TYPES.DUPLEX, SEQUENCE_TYPES.DIMER, SEQUENCE_TYPES.TRIPLEX].includes(typeCol.get(i))) ?
-        chemistryNameCol.get(i) :
-        sequenceCol.get(i);
-    } catch (err) {
-      onError(i, err);
-    }
-    return res;
-  });
-
-  df.columns.addNewString(COL_NAMES.COMPOUND_COMMENTS).init((i: number) => {
-    let res: string = '';
-    try {
-      if ([SEQUENCE_TYPES.SENSE_STRAND, SEQUENCE_TYPES.ANTISENSE_STRAND].includes(typeCol.get(i))) {
-        res = sequenceCol.get(i);
-      } else if (typeCol.get(i) == SEQUENCE_TYPES.DUPLEX) {
-        const obj = parseStrandsFromDuplexCell(sequenceCol.get(i));
-        res = `${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));
-        res = `${chemistryNameCol.get(i)}; duplex of SS: ${obj.SS} and AS1: ${obj.AS1} and AS2: ${obj.AS2}`;
-      }
-    } catch (err) {
-      onError(i, err);
-    }
-    return res;
-  });
-
-  df.columns.addNewFloat(COL_NAMES.COMPOUND_MOL_WEIGHT).init((i: number) => {
-    let res: number = Number.NaN;
-    try {
-      if ([SEQUENCE_TYPES.SENSE_STRAND, SEQUENCE_TYPES.ANTISENSE_STRAND].includes(typeCol.get(i))) {
-        res = (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));
-        res = (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));
-        res = (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;
-      }
-    } catch (err) {
-      onError(i, err);
-    }
-    return res;
-  });
-
-  df.columns.addNewFloat(COL_NAMES.SALT_MASS).init((i: number) => {
-    let res: number = Number.NaN;
-    try {
-      res = saltMass(saltNamesList, saltsMolWeightList, equivalentsCol, i, saltCol);
-    } catch (err) {
-      onError(i, err);
-    }
-    return res;
-  });
-
-  df.columns.addNewFloat(COL_NAMES.SALT_MOL_WEIGHT).init((i: number) => {
-    let res: number = Number.NaN;
-    try {
-      res = saltMolWeigth(saltNamesList, saltCol, saltsMolWeightList, i);
-    } catch (err) {
-      onError(i, err);
-    }
-    return res;
-  });
-
-  const compoundMolWeightCol = df.getCol(COL_NAMES.COMPOUND_MOL_WEIGHT);
-  const saltMassCol = df.getCol(COL_NAMES.SALT_MASS);
-  df.columns.addNewFloat(COL_NAMES.BATCH_MOL_WEIGHT).init((i: number) => {
-    let res: number = Number.NaN;
-    try {
-      res = batchMolWeight(compoundMolWeightCol, saltMassCol, i);
-    } catch (err) {
-      onError(i, err);
-    }
-    return res;
-  });
-
-  return df;
-}

package/src/utils/sdf-save-table.ts

@@ -1,56 +0,0 @@
-import * as DG from 'datagrok-api/dg';
-import {COL_NAMES, GENERATED_COL_NAMES, SEQUENCE_TYPES} from '../autostart/constants';
-import {differenceOfTwoArrays, download} from '../helpers';
-import * as grok from 'datagrok-api/grok';
-import {SYNTHESIZERS} from '../structures-works/map';
-import {sequenceToMolV3000} from '../structures-works/from-monomers';
-import {parseStrandsFromDuplexCell, parseStrandsFromTriplexOrDimerCell} from './parse';
-import {linkStrandsV3000} from '../structures-works/mol-transformations';
-
-export async function sdfSaveTable(table: DG.DataFrame, onError: (rowI: number, err: any) => void) {
-  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}'`);
-  }
-
-  const sequenceCol = table.getCol(COL_NAMES.SEQUENCE);
-  const typeCol = table.getCol(COL_NAMES.TYPE);
-
-  let resultStr = '';
-  const rowCount = table.rowCount;
-  for (let i = 0; i < rowCount; i++) {
-    try {
-      let rowStr = '';
-      const format = SYNTHESIZERS.GCRS; //getFormat(sequenceCol.get(i))!;
-      if (typeCol.get(i) == SEQUENCE_TYPES.SENSE_STRAND) {
-        rowStr += `${sequenceToMolV3000(sequenceCol.get(i), false, true, format)}\n> <Sequence>\nSense Strand\n\n`;
-      } else if (typeCol.get(i) == SEQUENCE_TYPES.ANTISENSE_STRAND) {
-        rowStr += `${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`;
-        rowStr += `${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`;
-        rowStr += `${linkStrandsV3000({senseStrands: [ss], antiStrands: [as1, as2]}, true)}\n\n`;
-      }
-
-      for (const col of table.columns) {
-        if (col.name != COL_NAMES.SEQUENCE)
-          rowStr += `> <${col.name}>\n${col.get(i)}\n\n`;
-      }
-
-      rowStr += '$$$$\n';
-
-      resultStr += rowStr;
-    } catch (err: any) {
-      onError(i, err);
-    }
-  }
-
-  download(`${table.name}.sdf`, encodeURIComponent(resultStr));
-}