@teselagen/sequence-utils 0.1.21 → 0.1.23

package/src/getDigestFragmentsForCutsites.js

@@ -0,0 +1,105 @@
+import {normalizePositionByRangeLength, getRangeLength} from "@teselagen/range-utils";
+
+export default function getDigestFragmentsForCutsites(
+  sequenceLength,
+  circular,
+  cutsites,
+  opts = {}
+) {
+  const fragments = [];
+  const overlappingEnzymes = [];
+  const pairs = [];
+  if (!cutsites.length) return [];
+  let sortedCutsites = cutsites.sort((a, b) => {
+    return a.topSnipPosition - b.topSnipPosition;
+  });
+
+  if (!circular) {
+    //if linear, add 2 fake cutsites for the start and end of the seq
+    sortedCutsites = [
+      {
+        topSnipPosition: 0,
+        bottomSnipPosition: 0,
+        overhangSize: 0,
+        type: "START_OR_END_OF_SEQ",
+        name: "START_OF_SEQ"
+      },
+      ...sortedCutsites,
+      {
+        topSnipPosition: sequenceLength,
+        bottomSnipPosition: sequenceLength,
+        overhangSize: 0,
+        type: "START_OR_END_OF_SEQ",
+        name: "END_OF_SEQ"
+      }
+    ];
+  }
+
+  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,
+      sequenceLength
+    );
+    const end = normalizePositionByRangeLength(
+      cut2.topSnipPosition - 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
+    });
+  });
+
+  fragments.filter(fragment => {
+    if (!fragment.size) {
+      overlappingEnzymes.push(fragment);
+      return false;
+    }
+    return true;
+  });
+  return fragments;
+};

package/src/getDigestFragmentsForRestrictionEnzymes.js

@@ -0,0 +1,27 @@
+import getDigestFragmentsForCutsites from "./getDigestFragmentsForCutsites";
+import cutSequenceByRestrictionEnzyme from "./cutSequenceByRestrictionEnzyme";
+import {flatMap} from "lodash";
+
+export default function getDigestFragmentsForRestrictionEnzymes(
+  sequence,
+  circular,
+  restrictionEnzymeOrEnzymes,
+  opts
+) {
+  const restrictionEnzymes = Array.isArray(restrictionEnzymeOrEnzymes)
+    ? restrictionEnzymeOrEnzymes
+    : [restrictionEnzymeOrEnzymes];
+  const cutsites = flatMap(restrictionEnzymes, restrictionEnzyme => {
+    return cutSequenceByRestrictionEnzyme(
+      sequence,
+      circular,
+      restrictionEnzyme
+    );
+  });
+  return getDigestFragmentsForCutsites(
+    sequence.length,
+    circular,
+    cutsites,
+    opts
+  );
+};

package/src/getDigestFragmentsForRestrictionEnzymes.test.js

@@ -0,0 +1,228 @@
+/* eslint-disable no-unused-expressions */
+import chai from "chai";
+import getDigestFragmentsForRestrictionEnzymes from "./getDigestFragmentsForRestrictionEnzymes.js";
+import enzymeList from "./aliasedEnzymesByName";
+
+chai.should();
+describe("getDigestFragmentsForRestrictionEnzymes", () => {
+  //bamhi
+  // "bamhi": {
+  //     "name": "bamhi",
+  //     "site": "ggatcdc",
+  //     "forwardRegex": "g{2}atc{2}",
+  //     "reverseRegex": "g{2}atc{2}",
+  //     "topSnipOffset": 1,
+  //     "bottomSnipOffset": 5
+  // },
+  // ATGATCAGA
+  // 012345678
+  it("returns 0 digestFragments for a linear seq with no cutsites", () => {
+    const digestFragments = getDigestFragmentsForRestrictionEnzymes(
+      "rrrrrrrrr",
+      false,
+      enzymeList["bsai"]
+    );
+    digestFragments.should.be.an("array");
+    digestFragments.length.should.equal(0);
+  });
+  it("returns 0 digestFragments for a circular seq with no cutsites", () => {
+    const digestFragments = getDigestFragmentsForRestrictionEnzymes(
+      "rrrrrrrrrrrr",
+      false,
+      enzymeList["bsai"]
+    );
+    digestFragments.should.be.an("array");
+    digestFragments.length.should.equal(0);
+  });
+  it("gets digestFragments for a single type 2s cutsite cutting in a linear sequence", () => {
+    const digestFragments = getDigestFragmentsForRestrictionEnzymes(
+      "tagagtagagtagaGGTCTCgtagagtagagtagag",
+      false,
+      enzymeList["bsai"]
+    );
+    digestFragments.should.be.an("array");
+    digestFragments.length.should.equal(2);
+    digestFragments[0].start.should.equal(0);
+    digestFragments[0].end.should.equal(20);
+
+    digestFragments[0].cut1.overhangSize.should.equal(0);
+    digestFragments[0].cut1.isOverhangIncludedInFragmentSize.should.equal(
+      false
+    );
+    digestFragments[0].cut2.overhangSize.should.equal(4);
+    digestFragments[0].cut2.isOverhangIncludedInFragmentSize.should.equal(
+      false
+    );
+
+    digestFragments[1].start.should.equal(21);
+    digestFragments[1].end.should.equal(35);
+    digestFragments[1].cut1.overhangSize.should.equal(4);
+    digestFragments[1].cut1.isOverhangIncludedInFragmentSize.should.equal(true);
+    digestFragments[1].cut2.overhangSize.should.equal(0);
+    digestFragments[1].cut2.isOverhangIncludedInFragmentSize.should.equal(
+      false
+    );
+  });
+  it("gets digestFragments for a single cutsite cutting in a circular sequence", () => {
+    const digestFragments = getDigestFragmentsForRestrictionEnzymes(
+      "GGATCC",
+      //
+      true,
+      enzymeList["bamhi"]
+    );
+    //  v
+    // G G A T C C
+    // C C T A G G
+    //          ^
+    digestFragments.should.be.an("array");
+    digestFragments.length.should.equal(1);
+    digestFragments[0].start.should.equal(1);
+    digestFragments[0].end.should.equal(0);
+    // I don't think we can determine containsFive/ThreePrimeRecognitionSite until the inclusion/exclusion of the overhangs is done
+    // digestFragments[0].containsFivePrimeRecognitionSite.should.equal(false)
+    // digestFragments[0].containsThreePrimeRecognitionSite.should.equal(false)
+    digestFragments[0].cut1.overhangSize.should.equal(4);
+    digestFragments[0].cut1.isOverhangIncludedInFragmentSize.should.equal(true);
+    digestFragments[0].cut2.overhangSize.should.equal(4);
+    digestFragments[0].cut2.isOverhangIncludedInFragmentSize.should.equal(
+      false
+    );
+  });
+  it("gets digestFragments for a single cutsite cutting in a linear sequence", () => {
+    const digestFragments = getDigestFragmentsForRestrictionEnzymes(
+      "ggatcc",
+      false,
+      enzymeList["bamhi"]
+    );
+    digestFragments.should.be.an("array");
+    digestFragments.length.should.equal(2);
+    digestFragments[0].cut1.overhangSize.should.equal(0);
+    digestFragments[0].cut1.isOverhangIncludedInFragmentSize.should.equal(
+      false
+    );
+    digestFragments[0].cut2.overhangSize.should.equal(4);
+    digestFragments[0].cut2.isOverhangIncludedInFragmentSize.should.equal(
+      false
+    );
+    digestFragments[0].start.should.equal(0);
+    digestFragments[0].end.should.equal(0);
+    digestFragments[1].cut1.overhangSize.should.equal(4);
+    digestFragments[1].cut1.isOverhangIncludedInFragmentSize.should.equal(true);
+    digestFragments[1].cut2.overhangSize.should.equal(0);
+    digestFragments[1].cut2.isOverhangIncludedInFragmentSize.should.equal(
+      false
+    );
+    digestFragments[1].start.should.equal(1);
+    digestFragments[1].end.should.equal(5);
+  });
+
+  it("gets digestFragments for multiple cutsites cutting in a linear sequence", () => {
+    const digestFragments = getDigestFragmentsForRestrictionEnzymes(
+      "ggatcctttttttggatcc",
+      false,
+      enzymeList["bamhi"]
+    );
+    digestFragments.should.be.an("array");
+    digestFragments.length.should.equal(3);
+    digestFragments[0].cut1.type.should.equal("START_OR_END_OF_SEQ");
+    digestFragments[2].cut2.type.should.equal("START_OR_END_OF_SEQ");
+    digestFragments[0].start.should.equal(0);
+    digestFragments[0].end.should.equal(0);
+    digestFragments[1].start.should.equal(1);
+    digestFragments[1].end.should.equal(13);
+    digestFragments[2].start.should.equal(14);
+    digestFragments[2].end.should.equal(18);
+  });
+  it("gets digestFragments for multiple cutsites cutting in a circular sequence", () => {
+    const digestFragments = getDigestFragmentsForRestrictionEnzymes(
+      "ggatcctttttttggatcc",
+      true,
+      enzymeList["bamhi"]
+    );
+    digestFragments.should.be.an("array");
+    digestFragments.length.should.equal(2);
+    digestFragments[0].start.should.equal(1);
+    digestFragments[0].end.should.equal(13);
+    digestFragments[0].size.should.equal(13);
+    digestFragments[1].start.should.equal(14);
+    digestFragments[1].end.should.equal(0);
+    digestFragments[1].size.should.equal(6);
+  });
+  it("gets digestFragments for multiple type 2s cutsites cutting in a circular sequence", () => {
+    const digestFragments = getDigestFragmentsForRestrictionEnzymes(
+      "GGTCTCttttttttttttGGTCTCttttttttttttttt",
+      //         ------------------
+      //  -------                  --------------
+
+      //             --------------
+      //  -------                      ----------
+      true,
+      enzymeList["bsai"]
+    );
+    digestFragments.should.be.an("array");
+    digestFragments.length.should.equal(2);
+    digestFragments[0].cut1.overhangSize.should.equal(4);
+    digestFragments[0].cut1.isOverhangIncludedInFragmentSize.should.equal(true);
+    digestFragments[0].cut2.overhangSize.should.equal(4);
+    digestFragments[0].cut2.isOverhangIncludedInFragmentSize.should.equal(
+      false
+    );
+    digestFragments[0].start.should.equal(7);
+    digestFragments[0].end.should.equal(24);
+    digestFragments[0].size.should.equal(18);
+
+    digestFragments[1].cut1.overhangSize.should.equal(4);
+    digestFragments[1].cut1.isOverhangIncludedInFragmentSize.should.equal(true);
+    digestFragments[1].cut2.overhangSize.should.equal(4);
+    digestFragments[1].cut2.isOverhangIncludedInFragmentSize.should.equal(
+      false
+    );
+    digestFragments[1].start.should.equal(25);
+    digestFragments[1].end.should.equal(6);
+    digestFragments[1].size.should.equal(21);
+  });
+  it("gets digestFragments for multiple cutsites cutting in a circular sequence when computePartialDigests=true", () => {
+    const digestFragments = getDigestFragmentsForRestrictionEnzymes(
+      "ggatcctttttttggatcc",
+      true,
+      enzymeList["bamhi"],
+      { computePartialDigests: true }
+    );
+
+    digestFragments.should.be.an("array");
+    digestFragments.length.should.equal(3);
+    digestFragments[0].start.should.equal(1);
+    digestFragments[0].end.should.equal(13);
+    digestFragments[0].size.should.equal(13);
+
+    digestFragments[1].start.should.equal(14);
+    digestFragments[1].end.should.equal(13);
+    digestFragments[1].size.should.equal(19);
+
+    digestFragments[2].start.should.equal(14);
+    digestFragments[2].end.should.equal(0);
+    digestFragments[2].size.should.equal(6);
+  });
+  //tnrtodo: this test should be enabled and checked for correctness
+  //   it("gets digestFragments for multiple cutsites cutting in a linear sequence when computePartialDigests=true", function() {
+  //     const digestFragments = getDigestFragmentsForRestrictionEnzymes(
+  //       "ggatcctttttttggatcc",
+  //       false,
+  //       enzymeList["bamhi"],
+  //       { computePartialDigests: true }
+  //     );
+  //     digestFragments.should.be.an("array");
+  //     digestFragments.length.should.equal(9);
+  //     digestFragments[0].start.should.equal(1);
+  //     digestFragments[0].end.should.equal(13);
+  //     digestFragments[0].size.should.equal(13);
+
+  //     digestFragments[1].start.should.equal(14);
+  //     digestFragments[1].end.should.equal(13);
+  //     digestFragments[1].size.should.equal(19);
+
+  //     digestFragments[2].start.should.equal(14);
+  //     digestFragments[2].end.should.equal(0);
+  //     digestFragments[2].size.should.equal(6);
+  //   });
+});

package/src/getInsertBetweenVals.js

@@ -0,0 +1,28 @@
+import {normalizePositionByRangeLength1Based} from "@teselagen/range-utils";
+
+export default function getInsertBetweenVals(
+  caretPosition,
+  selectionLayer,
+  sequenceLength
+) {
+  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/getInsertBetweenVals.test.js

@@ -0,0 +1,33 @@
+import assert from "assert";
+import getInsertBetweenVals from "./getInsertBetweenVals";
+describe("getInsertBetweenVals", () => {
+  it("should get 1 based insert between position X and position X2 based on either a 0-based caretPosition or a 0-based selectionLayer", () => {
+    // 0123
+    // atgc
+    // 1234
+    let insertBetween;
+    insertBetween = getInsertBetweenVals(1, {}, 4);
+    assert(insertBetween[0] === 1);
+    assert(insertBetween[1] === 2);
+
+    insertBetween = getInsertBetweenVals(0, {}, 4);
+    assert(insertBetween[0] === 4);
+    assert(insertBetween[1] === 1);
+
+    insertBetween = getInsertBetweenVals(-1, { start: 1, end: 1 }, 4);
+    assert(insertBetween[0] === 1);
+    assert(insertBetween[1] === 3);
+
+    insertBetween = getInsertBetweenVals(-1, { start: 0, end: 1 }, 4);
+    assert(insertBetween[0] === 4);
+    assert(insertBetween[1] === 3);
+
+    insertBetween = getInsertBetweenVals(-1, { start: 3, end: 1 }, 4);
+    assert(insertBetween[0] === 3);
+    assert(insertBetween[1] === 3);
+
+    insertBetween = getInsertBetweenVals(-1, { start: 3, end: 2 }, 4);
+    assert(insertBetween[0] === 3);
+    assert(insertBetween[1] === 4);
+  });
+});

package/src/getLeftAndRightOfSequenceInRangeGivenPosition.js

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

package/src/getLeftAndRightOfSequenceInRangeGivenPosition.test.js

@@ -0,0 +1,80 @@
+
+
+import chai from "chai";
+import cutSequenceByRestrictionEnzyme from "./cutSequenceByRestrictionEnzyme.js";
+import enzymeList from "./aliasedEnzymesByName";
+import getLeftAndRightOfSequenceInRangeGivenPosition from "./getLeftAndRightOfSequenceInRangeGivenPosition";
+
+chai.should();
+describe("getLeftAndRightOfSequenceInRangeGivenPosition", () => {
+  it("gets the left and right of the range correctly given a position inside the range", () => {
+    const sequence = "aaaaaaaaaattttttttttgggggggggg";
+    const result = getLeftAndRightOfSequenceInRangeGivenPosition(
+      { start: 9, end: 20 },
+      10,
+      sequence
+    );
+    result.leftHandSide.should.equal("a");
+    result.rightHandSide.should.equal("ttttttttttg");
+  });
+
+  it("gets the left and right of the range correctly given a position outside the range", () => {
+    const sequence = "aaaaaaaaaattttttttttgggggggggg";
+    const result = getLeftAndRightOfSequenceInRangeGivenPosition(
+      { start: 9, end: 20 },
+      6,
+      sequence
+    );
+    result.leftHandSide.should.equal("");
+    result.rightHandSide.should.equal("attttttttttg");
+  });
+
+  it("gets the left and right of the range correctly given a position outside the range", () => {
+    const sequence = "aaaaaaaaaattttttttttgggggggggg";
+    const result = getLeftAndRightOfSequenceInRangeGivenPosition(
+      { start: 9, end: 20 },
+      24,
+      sequence
+    );
+    result.leftHandSide.should.equal("attttttttttg");
+    result.rightHandSide.should.equal("");
+  });
+
+  //bamhi
+  // "bamhi": {
+  //     "name": "bamhi",
+  //     "site": "ggatcc",
+  //     "forwardRegex": "g{2}atc{2}",
+  //     "reverseRegex": "g{2}atc{2}",
+  //     "topSnipOffset": 1,
+  //     "bottomSnipOffset": 5
+  // },
+  it("cuts a single circular cutsite", () => {
+    const sequence = "ccrrrrggat";
+    const cutsites = cutSequenceByRestrictionEnzyme(
+      sequence,
+      true,
+      enzymeList["bamhi"]
+    );
+    const cutsite = cutsites[0];
+    const result = getLeftAndRightOfSequenceInRangeGivenPosition(
+      cutsite.recognitionSiteRange,
+      cutsite.topSnipPosition,
+      sequence
+    );
+    result.leftHandSide.should.equal("g");
+    result.rightHandSide.should.equal("gatcc");
+    //
+    // //
+    // cutsites.should.be.an("array");
+    // cutsites.length.should.equal(1);
+    // cutsites[0].start.should.equal(6);
+    // cutsites[0].end.should.equal(1);
+    // cutsites[0].recognitionSiteRange.start.should.equal(6);
+    // cutsites[0].recognitionSiteRange.end.should.equal(1);
+    // cutsites[0].topSnipPosition.should.equal(7);
+    // cutsites[0].bottomSnipPosition.should.equal(1);
+    // should.not.exist(cutsites[0].upstreamTopSnip);
+    // should.not.exist(cutsites[0].upstreamBottomSnip);
+  });
+});

package/src/getMassOfAaString.js

@@ -0,0 +1,24 @@
+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,
+  numsAfterDecimal = 2,
+  divideByThree = false
+) {
+  let sumMass = 0;
+  for (let i = 0; i < aaString.length; i++) {
+    sumMass += proteinAlphabet[aaString[i]].mass;
+  }
+  if (divideByThree) {
+    sumMass /= 3;
+  }
+  return Math.round(sumMass * 10 ** numsAfterDecimal) / 10 ** numsAfterDecimal;
+};

package/src/getMassofAaString.test.js

@@ -0,0 +1,18 @@
+import getMassOfAaString from "./getMassOfAaString";
+import assert from "assert";
+
+describe("getMassOfAaString", () => {
+  it("an empty string has a mass of 0", () => {
+    assert.equal(getMassOfAaString(""), 0);
+  });
+  it("A string with one amino acids returns the correct results", () => {
+    assert.equal(getMassOfAaString("T"), 119.1);
+    assert.equal(getMassOfAaString("A"), 89.1);
+    assert.equal(getMassOfAaString("F"), 165.2);
+  });
+  it("A string a long string of amino acids returns the correct results", () => {
+    assert.equal(getMassOfAaString("TAGATAFPFPFPA"), 1510.6);
+    assert.equal(getMassOfAaString("TFPMAV"), 754.8);
+    assert.equal(getMassOfAaString("TFPMAVTAGATAFPFPFPA"), 2265.4);
+  });
+});