@teselagen/sequence-utils 0.3.38-beta.2 → 0.3.41

package/src/findSequenceMatches.ts

@@ -1,154 +0,0 @@
-import {
-  modulateRangeBySequenceLength,
-  flipContainedRange,
-  Range
-} from "@teselagen/range-utils";
-import { reduce, uniqBy } from "lodash-es";
-import escapeStringRegexp from "escape-string-regexp";
-import getAminoAcidStringFromSequenceString from "./getAminoAcidStringFromSequenceString";
-import { ambiguous_dna_values, extended_protein_values } from "./bioData";
-import getReverseComplementSequenceString from "./getReverseComplementSequenceString";
-
-export interface FindSequenceMatchesOptions {
-  searchReverseStrand?: boolean;
-  isCircular?: boolean;
-  isAmbiguous?: boolean;
-  isProteinSequence?: boolean;
-  isProteinSearch?: boolean;
-}
-
-export default function findSequenceMatches(
-  sequence: string,
-  searchString: string,
-  options: FindSequenceMatchesOptions = {}
-): (Range & { bottomStrand?: boolean })[] {
-  let matches = findSequenceMatchesTopStrand(sequence, searchString, options);
-  const { searchReverseStrand } = options;
-
-  if (searchReverseStrand) {
-    const sequenceLength = sequence.length;
-    const reverseSeq = getReverseComplementSequenceString(sequence);
-    const reverseMatches = findSequenceMatchesTopStrand(
-      reverseSeq,
-      searchString,
-      options
-    );
-    const flippedReverseMatches = reverseMatches.map(range => {
-      return {
-        ...flipContainedRange(
-          range,
-          { start: 0, end: sequenceLength - 1 },
-          sequenceLength
-        ),
-        bottomStrand: true
-      };
-    });
-    matches = [...matches, ...flippedReverseMatches];
-  }
-  return matches;
-}
-
-function findSequenceMatchesTopStrand(
-  sequence: string,
-  searchString: string,
-  options: FindSequenceMatchesOptions = {}
-): Range[] {
-  const { isCircular, isAmbiguous, isProteinSequence, isProteinSearch } =
-    options;
-  let searchStringToUse = escapeStringRegexp(searchString);
-  if (isAmbiguous) {
-    if (isProteinSearch || isProteinSequence) {
-      searchStringToUse = convertAmbiguousStringToRegex(
-        searchStringToUse,
-        true
-      );
-    } else {
-      //we're searching DNA
-      searchStringToUse = convertAmbiguousStringToRegex(
-        searchStringToUse,
-        false
-      );
-    }
-  }
-  if (!searchStringToUse) return []; //short circuit if nothing is actually being searched for (eg searching for "%%"")
-  let sequenceToUse = sequence;
-  if (isCircular) {
-    sequenceToUse = sequenceToUse + sequenceToUse;
-  }
-
-  let sequencesToCheck = [{ seqToCheck: sequenceToUse, offset: 0 }];
-  if (isProteinSearch) {
-    sequencesToCheck = [
-      {
-        seqToCheck: getAminoAcidStringFromSequenceString(sequenceToUse, {
-          doNotExcludeAsterisk: true
-        }),
-        offset: 0
-      },
-      {
-        seqToCheck: getAminoAcidStringFromSequenceString(
-          sequenceToUse.substr(1),
-          { doNotExcludeAsterisk: true }
-        ),
-        offset: 1
-      },
-      {
-        seqToCheck: getAminoAcidStringFromSequenceString(
-          sequenceToUse.substr(2),
-          { doNotExcludeAsterisk: true }
-        ),
-        offset: 2
-      }
-    ];
-  }
-
-  const ranges: Range[] = [];
-  sequencesToCheck.forEach(({ seqToCheck, offset }) => {
-    const reg = new RegExp(searchStringToUse, "ig");
-    let match: RegExpExecArray | null;
-    let range: Range;
-    /* eslint-disable no-cond-assign*/
-
-    while ((match = reg.exec(seqToCheck)) !== null) {
-      range = {
-        start: match.index,
-        end: match.index + searchString.length - 1 //this should be the original searchString here j
-      };
-      if (isProteinSearch) {
-        range.start = range.start * 3 + offset;
-        range.end = range.end * 3 + 2 + offset;
-      }
-      ranges.push(modulateRangeBySequenceLength(range, sequence.length));
-      reg.lastIndex = match.index + 1;
-    }
-    /* eslint-enable no-cond-assign*/
-  });
-
-  return uniqBy(ranges, e => {
-    return e.start + "-" + e.end;
-  });
-}
-
-function convertAmbiguousStringToRegex(string: string, isProtein: boolean) {
-  // Search for a DNA subseq in sequence.
-  // use ambiguous values (like N = A or T or C or G, R = A or G etc.)
-  // searches only on forward strand
-  return reduce(
-    string,
-    (acc, char) => {
-      const value = isProtein
-        ? (extended_protein_values as Record<string, string>)[
-            char.toUpperCase()
-          ]
-        : (ambiguous_dna_values as Record<string, string>)[char.toUpperCase()];
-      if (!value) return acc;
-      if (value.length === 1) {
-        acc += value;
-      } else {
-        acc += `[${value}]`;
-      }
-      return acc;
-    },
-    ""
-  );
-}

package/src/generateAnnotations.ts

@@ -1,39 +0,0 @@
-import { generateRandomRange } from "@teselagen/range-utils";
-import shortid from "shortid";
-import { Annotation } from "./types";
-
-function generateAnnotations(
-  numberOfAnnotationsToGenerate: number,
-  start: number,
-  end: number,
-  maxLength: number
-): Annotation[] {
-  const result: Annotation[] = [];
-  for (let i = 0; i < numberOfAnnotationsToGenerate; i++) {
-    const annotation = generateAnnotation(start, end, maxLength);
-    result.push(annotation);
-  }
-  return result;
-}
-
-function generateAnnotation(
-  start: number,
-  end: number,
-  maxLength: number
-): Annotation {
-  const range = generateRandomRange(start, end, maxLength);
-  return {
-    ...range,
-    name: getRandomInt(0, 100000).toString(),
-    type: "misc_feature",
-    id: shortid(),
-    forward: Math.random() > 0.5,
-    notes: {}
-  };
-}
-
-function getRandomInt(min: number, max: number): number {
-  return Math.floor(Math.random() * (max - min)) + min;
-}
-
-export default generateAnnotations;

package/src/generateSequenceData.ts

@@ -1,212 +0,0 @@
-import generateAnnotations from "./generateAnnotations";
-import { SequenceData } from "./types";
-
-export default function generateSequenceData({
-  isProtein,
-  sequenceLength = 1000,
-  numFeatures,
-  numParts,
-  numPrimers,
-  numTranslations
-}: {
-  isProtein?: boolean;
-  sequenceLength?: number;
-  numFeatures?: number;
-  numParts?: number;
-  numPrimers?: number;
-  numTranslations?: number;
-} = {}): SequenceData {
-  const proteinSequence = isProtein
-    ? generateSequence(sequenceLength, true)
-    : "";
-  const sequence = !isProtein ? generateSequence(sequenceLength) : "";
-
-  return {
-    circular: isProtein ? false : Math.random() > 0.5,
-    name: "p-" + Math.floor(Math.random() * 100),
-    description: "",
-    isProtein: !!isProtein,
-    sequence,
-    proteinSequence,
-    translations: isProtein
-      ? []
-      : generateAnnotations(
-          numTranslations || 5,
-          0,
-          sequenceLength - 1,
-          sequenceLength / 3
-        ),
-    features: generateAnnotations(
-      numFeatures || 10,
-      0,
-      sequenceLength - 1,
-      sequenceLength / 3
-    ),
-    primers: isProtein
-      ? []
-      : generateAnnotations(numPrimers || 10, 0, sequenceLength - 1, 50),
-    parts: generateAnnotations(
-      numParts || 10,
-      0,
-      sequenceLength - 1,
-      sequenceLength / 3
-    )
-  };
-}
-
-// export default tidyUpSequenceData(exampleData)
-
-function generateSequence(m = 9, isProtein?: boolean): string {
-  let s = "";
-  const r = isProtein ? "ACDEFGHIKLMNPQRSTVWY" : "gatc"; // Added explicit protein string instead of empty string default behavior
-  for (let i = 0; i < m; i++) {
-    s += r.charAt(Math.floor(Math.random() * r.length));
-  }
-  return s;
-}
-
-// tnr: this is used to generate a very large, multi-featured sequence
-// var string = "ggggcccccgggggccc";
-// var reallyLongFakeSequence = "";
-// for (var i = 1; i < 100000; i++) {
-//   reallyLongFakeSequence += string;
-//   if (i % 100 === 0) {
-//     reallyLongFakeSequence += 'taafatg';
-//     sequenceData.features.push({
-//       id: i,
-//       start: parseInt(i * 10),
-//       end: parseInt(i * 10 + 100),
-//       name: 'cooljim',
-//       color: 'green',
-//       forward: true,
-//       annotationType: "feature"
-//     });
-//   }
-// }
-// sequenceData.sequence += reallyLongFakeSequence;
-//
-// export default function() {
-//   var baseSeqData = {
-//
-//   }
-//   function seqGen() {
-//
-//   }
-// }
-// "features" : [
-//     {
-//         "name" : "1",
-//         "type" : "misc_feature",
-//         "start" : 1,
-//         "end" : 1,
-//         "strand" : 1,
-//         "notes" : [],
-//         "color": 'blue'
-//     },
-//     {
-//         "name" : "2",
-//         "type" : "misc_feature",
-//         "start" : 1,
-//         "end" : 1,
-//         "strand" : 1,
-//         "notes" : [],
-//         "color": 'blue'
-//     },
-//     {
-//         "name" : "3",
-//         "type" : "misc_feature",
-//         "start" : 1,
-//         "end" : 1,
-//         "strand" : 1,
-//         "notes" : [],
-//         "color": 'blue'
-//     },
-//     {
-//         "name" : "4",
-//         "type" : "misc_feature",
-//         "start" : 1,
-//         "end" : 14,
-//         "strand" : 1,
-//         "notes" : [],
-//         "color": 'blue'
-//     },
-//     {
-//         "name" : "5",
-//         "type" : "misc_feature",
-//         "start" : 1,
-//         "end" : 1,
-//         "strand" : 1,
-//         "notes" : [],
-//         "color": 'blue'
-//     },
-//     {
-//         "name" : "6",
-//         "type" : "misc_feature",
-//         "id" : "5590c1978fafgw979df000a4f02c7a",
-//         "start" : 4,
-//         "end" : 6,
-//         "strand" : 1,
-//         "notes" : [],
-//         "color": 'orange'
-//     },
-//     {
-//         "name" : "housemouserousepouse",
-//         "type" : "misc_feature",
-//         "id" : "5590c197897fs9df000a4f02c7a",
-//         "start" : 4,
-//         "end" : 6,
-//         "strand" : 1,
-//         "notes" : [],
-//         "color": 'orange'
-//     },
-//     {
-//         "name" : "housemouserousepouse",
-//         "type" : "misc_feature",
-//         "id" : "5590c1978979dasdfaf000a4f02c7a",
-//         "start" : 4,
-//         "end" : 6,
-//         "strand" : 1,
-//         "notes" : [],
-//         "color": 'orange'
-//     },
-//     {
-//         "name" : "housemouserousepouse",
-//         "type" : "misc_feature",
-//         "id" : "5590c197faas8979df000a4f02c7a",
-//         "start" : 4,
-//         "end" : 6,
-//         "strand" : 1,
-//         "notes" : [],
-//         "color": 'orange'
-//     },
-//     {
-//         "name" : "housemouserousepouse",
-//         "type" : "misc_feature",
-//         "id" : "5590c1978979df000a4f02c7aasd",
-//         "start" : 4,
-//         "end" : 6,
-//         "strand" : 1,
-//         "notes" : [],
-//         "color": 'orange'
-//     },
-//     {
-//         "name" : "house",
-//         "type" : "misc_feature",
-//         "id" : "5590c1978979df000a4f02c7b",
-//         "start" : 70,
-//         "end" : 90,
-//         "strand" : 1,
-//         "notes" : [],
-//         "color": 'green'
-//     },
-//     {
-//         "name" : "weer",
-//         "type" : "misc_feature",
-//         "id" : "5590c1d88979df000a4f02f5c",
-//         "start" : 3,
-//         "end" : 69,
-//         "strand" : 1,
-//         "notes" : [],
-//         "color": 'red'
-//     }
-// ],

package/src/getAllInsertionsInSeqReads.ts

@@ -1,100 +0,0 @@
-// seqReads should be an array of objects [{name, seq, pos, cigar}, {name, seq, pos, cigar}, ...]
-
-export interface SeqRead {
-  name: string;
-  seq: string;
-  pos: number;
-  cigar: string;
-}
-
-export interface InsertionInfo {
-  bpPos: number;
-  number: number;
-}
-
-export default function getAllInsertionsInSeqReads(
-  seqReads: SeqRead[]
-): InsertionInfo[] {
-  const allInsertionsInSeqReads: InsertionInfo[] = [];
-  seqReads.forEach(seqRead => {
-    // split cigar string at M, D, or I (match, deletion, or insertion), e.g. ["2M", "3I", "39M", "3D"...]
-    const splitSeqRead = seqRead.cigar.match(/([0-9]*[MDI])/g);
-
-    if (!splitSeqRead) return;
-
-    for (let componentI = 0; componentI < splitSeqRead.length; componentI++) {
-      if (splitSeqRead[componentI].slice(-1) === "I") {
-        let bpPosOfInsertion = seqRead.pos;
-        const numberOfInsertions = Number(
-          splitSeqRead[componentI].slice(0, -1)
-        );
-        for (let i = 0; i < componentI; i++) {
-          if (splitSeqRead[i].slice(-1) !== "I") {
-            const previousComponentNumber = Number(
-              splitSeqRead[i].slice(0, -1)
-            );
-            bpPosOfInsertion += previousComponentNumber;
-          }
-        }
-        const insertionInfo = {
-          // keeping bpPos 1-based
-          bpPos: bpPosOfInsertion,
-          number: numberOfInsertions
-        };
-        allInsertionsInSeqReads.push(insertionInfo);
-      }
-    }
-  });
-  // sort insertions by ascending bp pos
-  const sortedInsertions = allInsertionsInSeqReads.sort((a, b) => {
-    return a.bpPos - b.bpPos;
-  });
-  // combine duplicate or overlapping insertions from seq reads
-  for (let i = 0; i < sortedInsertions.length - 1; i++) {
-    if (sortedInsertions[i].bpPos === sortedInsertions[i + 1].bpPos) {
-      if (sortedInsertions[i].number > sortedInsertions[i + 1].number) {
-        // remove the one with fewer number of gaps from array
-        sortedInsertions.splice(i + 1, 1);
-        i--;
-      } else if (sortedInsertions[i].number < sortedInsertions[i + 1].number) {
-        sortedInsertions.splice(i, 1);
-        i--;
-      } else if (
-        sortedInsertions[i].number === sortedInsertions[i + 1].number
-      ) {
-        sortedInsertions.splice(i, 1);
-        i--;
-      }
-    }
-  }
-  // sortedInsertions is an array of objects [{bpPos: bp pos of insertion, number: # of insertions}, {bpPos, number}, ...]
-  return sortedInsertions;
-}
-
-// function getAllInsertionsInSeqReads(seqReads) {
-//   let allInsertionBpPosInSeqReads = [];
-//   seqReads.forEach(seqRead => {
-//     // split cigar string at M, D, or I (match, deletion, or insertion)
-//     // ["2M", "3I", "39M", "3D"...]
-//     const splitSeqRead = seqRead.cigar.match(/([0-9]*[MDI])/g)
-//     splitSeqRead.forEach(component => {
-//       // keeping bpPos 1-based
-//       let bpPosOfInsertion = seqRead.pos;
-// if (component.slice(-1) === "I") {
-//   const numberOfInsertions = Number(component.slice(0, -1));
-//   const componentIndex = splitSeqRead.indexOf(component);
-//   for (let i = 0; i < componentIndex; i++) {
-//       const previousComponentNumber = Number(splitSeqRead[i].slice(0, -1));
-//       bpPosOfInsertion += previousComponentNumber;
-//     }
-//   for (let i = 1; i <= numberOfInsertions; i++) {
-//     allInsertionBpPosInSeqReads.push(bpPosOfInsertion - i);
-//   }
-// }
-//   });
-// });
-//   // allInsertionBpPosInSeqReads should be an array of bp pos [6, 15, 9, 2, 23...]
-//   // remove duplicates, organize in ascending order
-// const uniqueInsertionBpPos = [...new Set(allInsertionBpPosInSeqReads)].sort(function(a, b) { return a - b });
-//   return uniqueInsertionBpPos;
-// }