@datagrok/sequence-translator 1.0.17 → 1.1.0

package/src/sdf-tab/sequence-codes-tools.ts

@@ -1,347 +0,0 @@
-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 '../hardcode-to-be-eliminated/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/helpers.ts

@@ -1,28 +0,0 @@
-import * as DG from 'datagrok-api/dg';
-
-export function sortByStringLengthInDescendingOrder(array: string[]): string[] {
-  return array.sort(function(a, b) { return b.length - a.length; });
-}
-
-export function stringify(items: string[]): string {
-  return '["' + items.join('", "') + '"]';
-}
-
-export function download(name: string, href: string): void {
-  const element = document.createElement('a');
-  element.setAttribute('href', 'data:text/plain;charset=utf-8,' + href);
-  element.setAttribute('download', name);
-  element.click();
-}
-
-export function removeEmptyRows(t: DG.DataFrame, colToCheck: DG.Column): DG.DataFrame {
-  for (let i = t.rowCount - 1; i > -1; i--) {
-    if (colToCheck.getString(i) === '')
-      t.rows.removeAt(i, 1, false);
-  }
-  return t;
-}
-
-export function differenceOfTwoArrays(a: string[], b: string[]): string[] {
-  return a.filter((x) => !b.includes(x));
-}

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 '../utils/helpers';
-import {parseStrandsFromDuplexCell, parseStrandsFromTriplexOrDimerCell} from './parse';
-import {isValidSequence} from '../sdf-tab/sequence-codes-tools';
-import {batchMolWeight, molecularWeight, saltMass, saltMolWeigth} from '../autostart/calculations';
-import {weightsObj} from '../hardcode-to-be-eliminated/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 '../utils/helpers';
-import * as grok from 'datagrok-api/grok';
-import {SYNTHESIZERS} from '../hardcode-to-be-eliminated/map';
-import {sequenceToMolV3000} from '../utils/structures-works/from-monomers';
-import {parseStrandsFromDuplexCell, parseStrandsFromTriplexOrDimerCell} from './parse';
-import {linkStrandsV3000} from '../utils/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));
-}

package/src/utils/structures-works/draw-molecule.ts

@@ -1,84 +0,0 @@
-/* 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 {errorToConsole} from '@datagrok-libraries/utils/src/to-console';
-
-import $ from 'cash-dom';
-
-import {extractAtomDataV3000} from './mol-transformations';
-
-/** Draw molecule on the canvas and append it to the specified div, with the
- * option of zoom-in */
-export async function drawMolecule(
-  moleculeImgDiv: HTMLDivElement,
-  canvasWidth: number, canvasHeight: number,
-  molfile: string
-): Promise<void> {
-  // clear the div's content if any
-  async function drawMolfileOnCanvas(canvas: HTMLCanvasElement): Promise<void> {
-    await grok.functions.call('Chem:canvasMol', {
-      x: 0, y: 0, w: canvas.width, h: canvas.height, canvas: canvas,
-      molString: molfile, scaffoldMolString: '',
-      options: {normalizeDepiction: false, straightenDepiction: false}
-    });
-  };
-
-  async function drawZoomedInMolecule(): Promise<void> {
-    try {
-      const dialogDivStyle = {
-        overflowX: 'scroll',
-      };
-      const dialogDiv = ui.div([], {style: dialogDivStyle});
-
-      // dialogDiv size required, but now available before dialog show()
-      const atomCoordinates = extractAtomDataV3000(molfile);
-      // const cw: number = $(window).width() * 0.80; // dialogDiv.clientWidth
-      const clientHeight: number = $(window).height() * 0.70; // dialogDiv.clientHeight
-      const molWidth: number = Math.max(...atomCoordinates.x) - Math.min(...atomCoordinates.x);
-      const molHeight: number = Math.max(...atomCoordinates.y) - Math.min(...atomCoordinates.y);
-
-      // const wR: number = cw / molWidth;
-      const hR: number = clientHeight / molHeight;
-      const r: number = hR; // Math.max(wR, hR);
-      const dialogCanvasWidth = r * molWidth;
-      const dialogCanvasHeight = r * molHeight;
-
-      const dialogCanvas = ui.canvas(
-        dialogCanvasWidth * window.devicePixelRatio, dialogCanvasHeight * window.devicePixelRatio
-      );
-      dialogCanvas.style.width = `${dialogCanvasWidth}px`;
-      dialogCanvas.style.height = `${dialogCanvasHeight}px`;
-      await drawMolfileOnCanvas(dialogCanvas);
-
-      dialogDiv.appendChild(dialogCanvas);
-      ui.dialog('Molecule')
-        .add(dialogDiv)
-        .showModal(true);
-    } catch (err) {
-      const errStr = errorToConsole(err);
-      console.error(errStr);
-    }
-  };
-
-  // clear div's content if any
-  moleculeImgDiv.innerHTML = '';
-
-  if (molfile !== '') {
-    const canvas = ui.canvas(canvasWidth * window.devicePixelRatio, canvasHeight * window.devicePixelRatio);
-
-    // Draw zoomed-out molecule
-    canvas.style.width = `${canvasWidth}px`;
-    canvas.style.height = `${canvasHeight}px`;
-    canvas.style.borderStyle = 'solid';
-    canvas.style.borderColor = 'blue';
-    drawMolfileOnCanvas(canvas);
-
-    // Dialog with zoomed-in molecule
-    $(canvas).on('click', drawZoomedInMolecule);
-    $(canvas).on('mouseover', () => $(canvas).css('cursor', 'grab')); // for some reason 'zoom-in' value wouldn't work
-    $(canvas).on('mouseout', () => $(canvas).css('cursor', 'default'));
-
-    moleculeImgDiv.append(canvas);
-  }
-}