@teselagen/sequence-utils 0.3.37 → 0.3.38-beta.1

package/src/getDigestFragmentsForCutsites.ts

@@ -0,0 +1,126 @@
+import {
+  normalizePositionByRangeLength,
+  getRangeLength
+} from "@teselagen/range-utils";
+import { CutSite, DigestFragment } from "./types";
+
+export default function getDigestFragmentsForCutsites(
+  sequenceLength: number,
+  circular: boolean,
+  cutsites: CutSite[],
+  opts: { computePartialDigests?: boolean } = {}
+): DigestFragment[] {
+  const fragments: DigestFragment[] = [];
+  const overlappingEnzymes: DigestFragment[] = [];
+  const pairs: CutSite[][] = [];
+  if (!cutsites.length) return [];
+  let sortedCutsites = cutsites.sort((a, b) => {
+    return (a.topSnipPosition || 0) - (b.topSnipPosition || 0);
+  });
+
+  if (!circular) {
+    //if linear, add 2 fake cutsites for the start and end of the seq
+    sortedCutsites = [
+      {
+        start: 0,
+        end: 0,
+        topSnipPosition: 0,
+        bottomSnipPosition: 0,
+        overhangSize: 0,
+        type: "START_OR_END_OF_SEQ",
+        name: "START_OF_SEQ",
+        restrictionEnzyme: {
+          name: "START_OF_SEQ",
+          site: "",
+          forwardRegex: "",
+          reverseRegex: ""
+        }
+      },
+      ...sortedCutsites,
+      {
+        start: sequenceLength,
+        end: sequenceLength,
+        topSnipPosition: sequenceLength,
+        bottomSnipPosition: sequenceLength,
+        overhangSize: 0,
+        type: "START_OR_END_OF_SEQ",
+        name: "END_OF_SEQ",
+        restrictionEnzyme: {
+          name: "END_OF_SEQ",
+          site: "",
+          forwardRegex: "",
+          reverseRegex: ""
+        }
+      }
+    ];
+  }
+
+  sortedCutsites.forEach((cutsite1, index) => {
+    if (!circular && !sortedCutsites[index + 1]) {
+      return; //don't push a pair if the sequence is linear and we've reached the end of our cutsites array
+    }
+    if (opts.computePartialDigests) {
+      sortedCutsites.forEach((cs, index2) => {
+        if (index2 === index + 1 || index2 === 0) {
+          return;
+        }
+        pairs.push([cutsite1, sortedCutsites[index2]]);
+      });
+    }
+    pairs.push([
+      cutsite1,
+      sortedCutsites[index + 1] ? sortedCutsites[index + 1] : sortedCutsites[0]
+    ]);
+  });
+
+  pairs.forEach(([cut1, cut2]) => {
+    const start = normalizePositionByRangeLength(
+      cut1.topSnipPosition || 0,
+      sequenceLength
+    );
+    const end = normalizePositionByRangeLength(
+      (cut2.topSnipPosition || 0) - 1,
+      sequenceLength
+    );
+    const fragmentRange = { start, end };
+    const size = getRangeLength(fragmentRange, sequenceLength);
+
+    // const id = uniqid()
+    const id = start + "-" + end + "-" + size + "-";
+
+    // getRangeLength({ start, end }, sequenceLength);
+
+    fragments.push({
+      // I don't think we can determine containsFive/ThreePrimeRecognitionSite until the inclusion/exclusion of the overhangs is done
+      // containsFivePrimeRecognitionSite: cut1.type !== "START_OR_END_OF_SEQ" && isRangeWithinRange(cut1.recognitionSiteRange, fragmentRange, sequenceLength ) ,
+      // containsThreePrimeRecognitionSite: cut2.type !== "START_OR_END_OF_SEQ" && isRangeWithinRange(cut1.recognitionSiteRange,  fragmentRange, sequenceLength) ,
+      cut1: {
+        ...cut1,
+        isOverhangIncludedInFragmentSize:
+          cut1.type !== "START_OR_END_OF_SEQ" &&
+          cut1.overhangSize > 0 &&
+          cut1.topSnipBeforeBottom
+      },
+      cut2: {
+        ...cut2,
+        isOverhangIncludedInFragmentSize:
+          cut2.type !== "START_OR_END_OF_SEQ" &&
+          cut2.overhangSize > 0 &&
+          !cut2.topSnipBeforeBottom
+      },
+      ...fragmentRange,
+      size,
+      id,
+      name: `${cut1.restrictionEnzyme.name} -- ${cut2.restrictionEnzyme.name} ${size} bps` // Add missing name property
+    });
+  });
+
+  fragments.filter(fragment => {
+    if (!fragment.size) {
+      overlappingEnzymes.push(fragment);
+      return false;
+    }
+    return true;
+  });
+  return fragments;
+}

package/src/getDigestFragmentsForRestrictionEnzymes.ts

@@ -0,0 +1,50 @@
+import { computeDigestFragments } from "./computeDigestFragments";
+import getCutsitesFromSequence from "./getCutsitesFromSequence";
+import { CutSite, RestrictionEnzyme } from "./types";
+import { flatMap, uniqBy } from "lodash-es";
+
+export default function getDigestFragmentsForRestrictionEnzymes(
+  sequence: string,
+  circular: boolean,
+  contextEnzymes: RestrictionEnzyme[] | RestrictionEnzyme,
+  options?: {
+    computePartialDigest?: boolean;
+    computePartialDigests?: boolean; // alias
+    computeDigestDisabled?: boolean; // corrected spelling if needed, but keeping as is
+    computePartialDigestDisabled?: boolean;
+    includeOverAndUnderHangs?: boolean;
+  }
+) {
+  const cutsitesByName = getCutsitesFromSequence(
+    sequence,
+    circular,
+    Array.isArray(contextEnzymes) ? contextEnzymes : [contextEnzymes]
+  );
+  const digest = computeDigestFragments({
+    cutsites: flatMap(cutsitesByName) as CutSite[],
+    sequenceLength: sequence.length,
+    circular,
+    ...options,
+    computePartialDigest:
+      options?.computePartialDigest || options?.computePartialDigests
+  });
+  const fragments = uniqBy(digest.fragments, fragment => {
+    return `${fragment.start}-${fragment.end}-${fragment.size}`;
+  });
+  if (
+    circular &&
+    (options?.computePartialDigest || options?.computePartialDigests)
+  ) {
+    // filter out the full length fragment if it's a duplicate
+    const fullLengthFragmentIndex = fragments.findIndex(
+      f => f.size === sequence.length
+    );
+    if (fullLengthFragmentIndex > -1) {
+      fragments.splice(fullLengthFragmentIndex, 1);
+    }
+  }
+
+  return fragments.sort((a, b) => {
+    return a.start - b.start || b.size - a.size;
+  });
+}

package/src/getInsertBetweenVals.ts

@@ -0,0 +1,31 @@
+import {
+  normalizePositionByRangeLength1Based,
+  Range
+} from "@teselagen/range-utils";
+
+export default function getInsertBetweenVals(
+  caretPosition: number,
+  selectionLayer: Range,
+  sequenceLength: number
+): [number, number] {
+  if (selectionLayer.start > -1) {
+    //selection layer
+    return [
+      normalizePositionByRangeLength1Based(
+        selectionLayer.start,
+        sequenceLength
+      ),
+      normalizePositionByRangeLength1Based(
+        selectionLayer.end + 2,
+        sequenceLength
+      )
+    ];
+  } else if (caretPosition > -1) {
+    return [
+      normalizePositionByRangeLength1Based(caretPosition, sequenceLength),
+      normalizePositionByRangeLength1Based(caretPosition + 1, sequenceLength)
+    ];
+  } else {
+    return [sequenceLength, 1];
+  }
+}

package/src/getLeftAndRightOfSequenceInRangeGivenPosition.ts

@@ -0,0 +1,40 @@
+import {
+  isPositionWithinRange,
+  getSequenceWithinRange,
+  normalizePositionByRangeLength,
+  isPositionCloserToRangeStartThanRangeEnd,
+  Range
+} from "@teselagen/range-utils";
+
+export default function getLeftAndRightOfSequenceInRangeGivenPosition(
+  range: Range,
+  position: number,
+  sequence: string
+): { leftHandSide: string; rightHandSide: string } {
+  const result = {
+    leftHandSide: "",
+    rightHandSide: ""
+  };
+  if (isPositionWithinRange(position, range, sequence.length)) {
+    result.leftHandSide = getSequenceWithinRange(
+      {
+        start: range.start,
+        end: normalizePositionByRangeLength(position - 1, sequence.length)
+      },
+      sequence
+    ) as string;
+    result.rightHandSide = getSequenceWithinRange(
+      { start: position, end: range.end },
+      sequence
+    ) as string;
+  } else {
+    if (
+      isPositionCloserToRangeStartThanRangeEnd(position, range, sequence.length)
+    ) {
+      result.rightHandSide = getSequenceWithinRange(range, sequence) as string;
+    } else {
+      result.leftHandSide = getSequenceWithinRange(range, sequence) as string;
+    }
+  }
+  return result;
+}

package/src/getMassOfAaString.ts

@@ -0,0 +1,29 @@
+import proteinAlphabet from "./proteinAlphabet";
+
+/**
+ * @param {string} aaString A string of amino acid characters
+ * @param {number} numsAfterDecimal the number of digits to round to after the decimal point, must be greater than 0
+ * @param {boolean} divideByThree divide the final mass by three,
+ *  this is useful in situtations where nucelotides are converted to
+ *  amino acids in a way that the amino acid appears three times
+ * @returns The sum of the mass of all amino acids in the string
+ */
+export default function getMassOfAaString(
+  aaString: string,
+  numsAfterDecimal = 2,
+  divideByThree = false
+) {
+  let sumMass = 0;
+  for (let i = 0; i < aaString.length; i++) {
+    sumMass += (proteinAlphabet as Record<string, { mass: number }>)[
+      aaString[i]
+    ].mass;
+  }
+  if (divideByThree) {
+    sumMass /= 3;
+  }
+  if (aaString.length > 0) {
+    sumMass = sumMass + 18.0153;
+  }
+  return Math.round(sumMass * 10 ** numsAfterDecimal) / 10 ** numsAfterDecimal;
+}

package/src/getOrfsFromSequence.ts

@@ -0,0 +1,132 @@
+import shortid from "shortid";
+import { Annotation } from "./types";
+import getReverseComplementSequenceString from "./getReverseComplementSequenceString";
+
+interface GetOrfsOptions {
+  sequence: string;
+  minimumOrfSize: number;
+  forward: boolean;
+  circular?: boolean;
+  useAdditionalOrfStartCodons?: boolean;
+}
+
+export interface Orf extends Annotation {
+  internalStartCodonIndices: number[];
+  frame: number;
+  // annotationTypePlural: string; // Annotation might already have this or it's extra
+  isOrf: boolean;
+  remove?: boolean;
+  length: number;
+}
+
+/**
+ * @private
+ * Finds ORFs in a given DNA forward in a given frame.
+ * frame - The frame to look in.
+ * sequence - The dna sequence.
+ * minimumOrfSize - The minimum length of ORF to return.
+ * forward - Should we find forward facing orfs or reverse facing orfs
+ * return - The list of ORFs found.
+ */
+export default function getOrfsFromSequence(options: GetOrfsOptions): Orf[] {
+  let sequence = options.sequence;
+  const minimumOrfSize = options.minimumOrfSize;
+  const forward = options.forward;
+  const circular = options.circular;
+  const useAdditionalOrfStartCodons = options.useAdditionalOrfStartCodons;
+
+  const originalSequenceLength = sequence.length;
+  if (!forward) {
+    //we reverse the sequence
+    sequence = getReverseComplementSequenceString(sequence);
+  }
+
+  if (circular) {
+    //we'll pass in double the sequence and then trim excess orfs
+    sequence += sequence;
+  }
+  const re = useAdditionalOrfStartCodons
+    ? /(?=((?:A[TU]G|G[TU]G|C[TU]G)(?:.{3})*?(?:[TU]AG|[TU]AA|[TU]GA)))/gi
+    : /(?=((?:A[TU]G)(?:.{3})*?(?:[TU]AG|[TU]AA|[TU]GA)))/gi;
+  let m: RegExpExecArray | null;
+  const orfRanges: Orf[] = [];
+  //loop through orf hits!
+  /* eslint-disable no-cond-assign*/
+
+  while ((m = re.exec(sequence)) !== null) {
+    //stuff to get the regex to work
+    if (m.index === re.lastIndex) {
+      re.lastIndex++;
+    }
+    //orf logic:
+    const orfLength = m[1].length;
+    if (orfLength >= minimumOrfSize) {
+      //only keep orfs >= to the minimum size
+      const start = m.index;
+      let end = orfLength + start - 1;
+      //normalize the end if it is greater than the original sequence length
+      if (end >= originalSequenceLength) {
+        end -= originalSequenceLength;
+      }
+      if (start < originalSequenceLength) {
+        //only keep orfs that *begin* before the original sequence length (only the case when dealing with circular orfs)
+        orfRanges.push({
+          start: start,
+          end: end,
+          length: m[1].length,
+          internalStartCodonIndices: [],
+          frame: start % 3,
+          forward: forward,
+          // annotationTypePlural: "orfs",
+          isOrf: true,
+          id: shortid(),
+          type: "orf",
+          name: "ORF"
+        } as Orf);
+      }
+    }
+  }
+  // pair down the orfs to remove duplicates
+  // and deal with revComp orfs
+  const orfEnds: Record<number, number> = {};
+  orfRanges.forEach((orf, index) => {
+    const indexOfAlreadyExistingOrf = orfEnds[orf.end];
+
+    if (typeof indexOfAlreadyExistingOrf !== "undefined") {
+      let internalOrf = orf;
+      let containingOrf = orfRanges[indexOfAlreadyExistingOrf];
+      if (containingOrf.length < internalOrf.length) {
+        internalOrf = orfRanges[indexOfAlreadyExistingOrf];
+        containingOrf = orf;
+        orfEnds[orf.end] = index;
+      }
+      const internalStartCodonIndex = forward
+        ? internalOrf.start
+        : originalSequenceLength - internalOrf.start - 1; //use either the start or the end depending on the direction of the internalOrf
+      //we know because of how the regex works that larger orfs come first in the array
+      containingOrf.internalStartCodonIndices = [
+        ...containingOrf.internalStartCodonIndices,
+        ...internalOrf.internalStartCodonIndices,
+        internalStartCodonIndex
+      ];
+      //set a flag that we'll use to remove all these shorter, duplicated orfs
+      internalOrf.remove = true;
+    } else {
+      orfEnds[orf.end] = index;
+      if (!forward) {
+        //this check needs to come after the above assignment of orfEnds
+        //flip the start and ends
+        const endHolder = orf.end; //temp variable
+        orf.end = originalSequenceLength - orf.start - 1;
+        orf.start = originalSequenceLength - endHolder - 1;
+      }
+    }
+  });
+  const nonDuplicatedOrfRanges = orfRanges.filter(orf => {
+    if (!orf.remove) {
+      return true;
+    }
+    return false;
+  });
+  return nonDuplicatedOrfRanges;
+}

package/src/getOverlapBetweenTwoSequences.ts

@@ -0,0 +1,30 @@
+import { modulatePositionByRange, Range } from "@teselagen/range-utils";
+
+/**
+ * This function gets the overlapping of one sequence to another based on sequence equality.
+ *
+ * @param  {string} sequenceToFind
+ * @param  {string} sequenceToSearchIn
+ * @param  {object} options            optional
+ * @return {object || null}            null if no overlap exists or a range object with .start and .end properties
+ */
+export default function getOverlapBetweenTwoSequences(
+  sequenceToFind: string,
+  sequenceToSearchIn: string
+): Range | null {
+  sequenceToSearchIn = sequenceToSearchIn.toLowerCase();
+  sequenceToFind = sequenceToFind.toLowerCase();
+  const lengthenedSeqToSearch = sequenceToSearchIn + sequenceToSearchIn;
+  const index = lengthenedSeqToSearch.indexOf(sequenceToFind);
+  if (index > -1) {
+    return {
+      start: index,
+      end: modulatePositionByRange(index + sequenceToFind.length - 1, {
+        start: 0,
+        end: sequenceToSearchIn.length - 1
+      })
+    };
+  } else {
+    return null;
+  }
+}

package/src/getPossiblePartsFromSequenceAndEnzymes.ts

@@ -0,0 +1,149 @@
+import getComplementSequenceString from "./getComplementSequenceString";
+import { normalizePositionByRangeLength } from "@teselagen/range-utils";
+import cutSequenceByRestrictionEnzyme from "./cutSequenceByRestrictionEnzyme";
+import { CutSite, RestrictionEnzyme, SequenceData } from "./types";
+
+export interface PartBetweenEnzymes {
+  start: number;
+  start1Based: number;
+  end: number;
+  end1Based: number;
+  firstCut: CutSite;
+  firstCutOffset: number;
+  firstCutOverhang: string;
+  firstCutOverhangTop: string;
+  firstCutOverhangBottom: string;
+  secondCut: CutSite;
+  secondCutOffset: number;
+  secondCutOverhang: string;
+  secondCutOverhangTop: string;
+  secondCutOverhangBottom: string;
+}
+
+export default function getPossiblePartsFromSequenceAndEnzymes(
+  seqData: SequenceData,
+  restrictionEnzymes: RestrictionEnzyme | RestrictionEnzyme[]
+): PartBetweenEnzymes[] {
+  // ac.throw([
+  //     ac.string,
+  //     ac.bool,
+  //     ac.shape({
+  //         "name": ac.string,
+  //         "site": ac.string,
+  //         "forwardRegex": ac.string,
+  //         "reverseRegex": ac.string,
+  //         "topSnipOffset": ac.number,
+  //         "bottomSnipOffset": ac.number
+  //     })
+  // ], arguments);
+  const enzymes = Array.isArray(restrictionEnzymes)
+    ? restrictionEnzymes
+    : [restrictionEnzymes];
+
+  const bps = seqData.sequence;
+  const seqLen = bps.length;
+  const circular = seqData.circular || false;
+  let cutsites: CutSite[] = [];
+  enzymes.forEach(enzyme => {
+    const newCutsites = cutSequenceByRestrictionEnzyme(bps, circular, enzyme);
+    cutsites = cutsites.concat(newCutsites);
+  });
+  const parts: PartBetweenEnzymes[] = [];
+  if (cutsites.length < 1) {
+    return parts;
+  } else if (cutsites.length === 1) {
+    parts.push(
+      getPartBetweenEnzymesWithInclusiveOverhangs(
+        cutsites[0],
+        cutsites[0],
+        seqLen
+      )
+    );
+    return parts;
+  } else {
+    const pairs = pairwise(cutsites);
+    pairs.forEach(pair => {
+      const cut1 = pair[0];
+      const cut2 = pair[1];
+      const part1 = getPartBetweenEnzymesWithInclusiveOverhangs(
+        cut1,
+        cut2,
+        seqLen
+      );
+      const part2 = getPartBetweenEnzymesWithInclusiveOverhangs(
+        cut2,
+        cut1,
+        seqLen
+      );
+      if (circular || !(part1.start > part1.end)) {
+        //only add origin spanning parts if the sequence is circular
+        parts.push(part1);
+      }
+      if (circular || !(part2.start > part2.end)) {
+        //only add origin spanning parts if the sequence is circular
+        parts.push(part2);
+      }
+    });
+    return parts;
+  }
+}
+
+function getPartBetweenEnzymesWithInclusiveOverhangs(
+  cut1: CutSite,
+  cut2: CutSite,
+  seqLen: number
+): PartBetweenEnzymes {
+  const firstCutOffset = getEnzymeRelativeOffset(cut1.restrictionEnzyme);
+  const secondCutOffset = getEnzymeRelativeOffset(cut2.restrictionEnzyme);
+  const start =
+    (cut1.topSnipBeforeBottom
+      ? cut1.topSnipPosition
+      : cut1.bottomSnipPosition) || 0;
+  const end = normalizePositionByRangeLength(
+    (cut2.topSnipBeforeBottom
+      ? cut2.bottomSnipPosition || 0
+      : cut2.topSnipPosition || 0) - 1,
+    seqLen
+  );
+  return {
+    start,
+    start1Based: start + 1,
+    end,
+    end1Based: end + 1,
+    firstCut: cut1,
+    //the offset is always counting with 0 being at the top snip position
+    firstCutOffset,
+    firstCutOverhang: cut1.overhangBps || "",
+    firstCutOverhangTop: firstCutOffset > 0 ? cut1.overhangBps || "" : "",
+    firstCutOverhangBottom:
+      firstCutOffset < 0
+        ? getComplementSequenceString(cut1.overhangBps || "")
+        : "",
+    secondCut: cut2,
+    //the offset is always counting with 0 being at the top snip position
+    secondCutOffset,
+    secondCutOverhang: cut2.overhangBps || "",
+    secondCutOverhangTop: secondCutOffset < 0 ? cut2.overhangBps || "" : "",
+    secondCutOverhangBottom:
+      secondCutOffset > 0
+        ? getComplementSequenceString(cut2.overhangBps || "")
+        : ""
+  };
+}
+
+function getEnzymeRelativeOffset(enzyme: RestrictionEnzyme): number {
+  //the offset is always counting with 0 being at the top snip position
+  return (enzyme.bottomSnipOffset || 0) - (enzyme.topSnipOffset || 0);
+}
+
+function pairwise<T>(list: T[]): T[][] {
+  if (list.length < 2) {
+    return [];
+  }
+  const first = list[0],
+    rest = list.slice(1),
+    pairs = rest.map(x => {
+      return [first, x];
+    });
+  return pairs.concat(pairwise(rest));
+}

package/src/getReverseAminoAcidStringFromSequenceString.ts

@@ -0,0 +1,22 @@
+import getAminoAcidDataForEachBaseOfDna from "./getAminoAcidDataForEachBaseOfDna";
+
+export default function getReverseAminoAcidStringFromSequenceString(
+  sequenceString: string
+) {
+  const aminoAcidsPerBase = getAminoAcidDataForEachBaseOfDna(
+    sequenceString,
+    false,
+    null,
+    false
+  );
+  const aaArray: string[] = [];
+  let aaString = "";
+  aminoAcidsPerBase.forEach(aa => {
+    if (!aa.fullCodon) {
+      return;
+    }
+    aaArray[aa.aminoAcidIndex] = aa.aminoAcid.value;
+  });
+  aaString = aaArray.join("");
+  return aaString;
+}

package/src/getReverseComplementAminoAcidStringFromSequenceString.ts

@@ -0,0 +1,10 @@
+import getAminoAcidStringFromSequenceString from "./getAminoAcidStringFromSequenceString";
+import getReverseComplementSequenceString from "./getReverseComplementSequenceString";
+
+export default function getReverseComplementAminoAcidStringFromSequenceString(
+  sequenceString: string
+): string {
+  return getAminoAcidStringFromSequenceString(
+    getReverseComplementSequenceString(sequenceString)
+  );
+}

package/src/getReverseComplementAnnotation.ts

@@ -0,0 +1,33 @@
+import { Annotation } from "./types";
+
+export default function getReverseComplementAnnotation(
+  annotation: Annotation,
+  sequenceLength: number
+) {
+  //note this function assumes that the entire sequence (or subsequence) is being reverse complemented
+  //TNR: this is what is happening:
+  //0123456789
+  //-feature--   //normal
+  //--erutaef-   //reverse complemented
+
+  //sequence length = 10
+  //feature start = 1
+  //feature end = 7
+  //so, erutaef start = 2 = 10 - (7+1)
+  //and, erutaef end = 8 = 10 - (1+1)
+
+  return Object.assign({}, annotation, {
+    start: sequenceLength - (annotation.end + 1),
+    end: sequenceLength - (annotation.start + 1),
+    forward: !annotation.forward,
+    strand: annotation.strand === 1 ? -1 : 1,
+    ...(annotation.locations && {
+      locations: annotation.locations.map(location => {
+        return {
+          start: sequenceLength - (location.end + 1),
+          end: sequenceLength - (location.start + 1)
+        };
+      })
+    })
+  });
+}