@teselagen/sequence-utils 0.1.21 → 0.1.23

package/src/getAminoAcidDataForEachBaseOfDna.test.js

@@ -0,0 +1,424 @@
+
+
+import getAminoAcidDataForEachBaseOfDna from "./getAminoAcidDataForEachBaseOfDna.js";
+
+import getAA from "./getAminoAcidFromSequenceTriplet";
+
+import assert from "assert";
+
+let aaData;
+describe("getAminoAcidDataForEachBaseOfDna tranlates a", () => {
+  //: It gets correct amino acid mapping and position in codon for each basepair in sequence
+  it("1 amino acid long sequence", () => {
+    aaData = getAminoAcidDataForEachBaseOfDna("atg", true);
+    assert.deepEqual(aaData, [
+      {
+        aminoAcid: getAA("atg"),
+        positionInCodon: 0,
+        aminoAcidIndex: 0,
+        sequenceIndex: 0,
+        codonRange: {
+          start: 0,
+          end: 2
+        },
+        fullCodon: true
+      },
+      {
+        aminoAcid: getAA("atg"),
+        positionInCodon: 1,
+        aminoAcidIndex: 0,
+        sequenceIndex: 1,
+        codonRange: {
+          start: 0,
+          end: 2
+        },
+        fullCodon: true
+      },
+      {
+        aminoAcid: getAA("atg"),
+        positionInCodon: 2,
+        aminoAcidIndex: 0,
+        sequenceIndex: 2,
+        codonRange: {
+          start: 0,
+          end: 2
+        },
+        fullCodon: true
+      }
+    ]);
+  });
+  it("1 amino acid long sequence which is subrange of a larger sequence", () => {
+    aaData = getAminoAcidDataForEachBaseOfDna(
+      "atgtatgagagtagagatagagata",
+      true,
+      { start: 4, end: 6 }
+    );
+    assert.deepEqual(aaData, [
+      {
+        aminoAcid: getAA("atg"),
+        positionInCodon: 0,
+        aminoAcidIndex: 0,
+        sequenceIndex: 4,
+        codonRange: {
+          start: 4,
+          end: 6
+        },
+        fullCodon: true
+      },
+      {
+        aminoAcid: getAA("atg"),
+        positionInCodon: 1,
+        aminoAcidIndex: 0,
+        sequenceIndex: 5,
+        codonRange: {
+          start: 4,
+          end: 6
+        },
+        fullCodon: true
+      },
+      {
+        aminoAcid: getAA("atg"),
+        positionInCodon: 2,
+        aminoAcidIndex: 0,
+        sequenceIndex: 6,
+        codonRange: {
+          start: 4,
+          end: 6
+        },
+        fullCodon: true
+      }
+    ]);
+  });
+  it("1 amino acid long sequence which is origin spanning subrange of a larger sequence", () => {
+    //                                         012345678
+    aaData = getAminoAcidDataForEachBaseOfDna("atgatgatg", true, {
+      start: 6,
+      end: 2
+    });
+    assert.deepEqual(aaData, [
+      {
+        aminoAcid: getAA("atg"),
+        positionInCodon: 0,
+        aminoAcidIndex: 0,
+        sequenceIndex: 6,
+        codonRange: {
+          start: 6,
+          end: 8
+        },
+        fullCodon: true
+      },
+      {
+        aminoAcid: getAA("atg"),
+        positionInCodon: 1,
+        aminoAcidIndex: 0,
+        sequenceIndex: 7,
+        codonRange: {
+          start: 6,
+          end: 8
+        },
+        fullCodon: true
+      },
+      {
+        aminoAcid: getAA("atg"),
+        positionInCodon: 2,
+        aminoAcidIndex: 0,
+        sequenceIndex: 8,
+        codonRange: {
+          start: 6,
+          end: 8
+        },
+        fullCodon: true
+      },
+      {
+        aminoAcid: getAA("atg"),
+        positionInCodon: 0,
+        aminoAcidIndex: 1,
+        sequenceIndex: 0,
+        codonRange: {
+          start: 0,
+          end: 2
+        },
+        fullCodon: true
+      },
+      {
+        aminoAcid: getAA("atg"),
+        positionInCodon: 1,
+        aminoAcidIndex: 1,
+        sequenceIndex: 1,
+        codonRange: {
+          start: 0,
+          end: 2
+        },
+        fullCodon: true
+      },
+      {
+        aminoAcid: getAA("atg"),
+        positionInCodon: 2,
+        aminoAcidIndex: 1,
+        sequenceIndex: 2,
+        codonRange: {
+          start: 0,
+          end: 2
+        },
+        fullCodon: true
+      }
+    ]);
+  });
+  it("1 amino acid long sequence in reverse direction", () => {
+    aaData = getAminoAcidDataForEachBaseOfDna("atg", false);
+    assert.deepEqual(aaData, [
+      {
+        aminoAcid: getAA("cat"),
+        positionInCodon: 2,
+        aminoAcidIndex: 0,
+        fullCodon: true,
+        sequenceIndex: 0,
+        codonRange: {
+          start: 0,
+          end: 2
+        }
+      },
+      {
+        aminoAcid: getAA("cat"),
+        positionInCodon: 1,
+        aminoAcidIndex: 0,
+        fullCodon: true,
+        sequenceIndex: 1,
+        codonRange: {
+          start: 0,
+          end: 2
+        }
+      },
+      {
+        aminoAcid: getAA("cat"),
+        positionInCodon: 0,
+        aminoAcidIndex: 0,
+        fullCodon: true,
+        sequenceIndex: 2,
+        codonRange: {
+          start: 0,
+          end: 2
+        }
+      }
+    ]);
+  });
+  it("> 1 amino acid long sequence", () => {
+    aaData = getAminoAcidDataForEachBaseOfDna("atgtaat", true);
+    assert.deepEqual(aaData, [
+      {
+        aminoAcid: getAA("atg"),
+        positionInCodon: 0,
+        aminoAcidIndex: 0,
+        fullCodon: true,
+        sequenceIndex: 0,
+        codonRange: {
+          start: 0,
+          end: 2
+        }
+      },
+      {
+        aminoAcid: getAA("atg"),
+        positionInCodon: 1,
+        aminoAcidIndex: 0,
+        fullCodon: true,
+        sequenceIndex: 1,
+        codonRange: {
+          start: 0,
+          end: 2
+        }
+      },
+      {
+        aminoAcid: getAA("atg"),
+        positionInCodon: 2,
+        aminoAcidIndex: 0,
+        fullCodon: true,
+        sequenceIndex: 2,
+        codonRange: {
+          start: 0,
+          end: 2
+        }
+      },
+      {
+        aminoAcid: getAA("taa"),
+        positionInCodon: 0,
+        aminoAcidIndex: 1,
+        fullCodon: true,
+        sequenceIndex: 3,
+        codonRange: {
+          start: 3,
+          end: 5
+        }
+      },
+      {
+        aminoAcid: getAA("taa"),
+        positionInCodon: 1,
+        aminoAcidIndex: 1,
+        fullCodon: true,
+        sequenceIndex: 4,
+        codonRange: {
+          start: 3,
+          end: 5
+        }
+      },
+      {
+        aminoAcid: getAA("taa"),
+        positionInCodon: 2,
+        aminoAcidIndex: 1,
+        fullCodon: true,
+        sequenceIndex: 5,
+        codonRange: {
+          start: 3,
+          end: 5
+        }
+      },
+      {
+        aminoAcid: getAA("xxx"),
+        positionInCodon: 0,
+        aminoAcidIndex: 2,
+        fullCodon: false,
+        sequenceIndex: 6,
+        codonRange: {
+          start: 6,
+          end: 6
+        }
+      }
+    ]);
+  });
+  it("> 1 amino acid long sequence in reverse direction", () => {
+    aaData = getAminoAcidDataForEachBaseOfDna("atgtaat", false);
+
+    assert.deepEqual(aaData, [
+      {
+        aminoAcid: getAA("xxx"),
+        positionInCodon: 0,
+        aminoAcidIndex: 2,
+        sequenceIndex: 0,
+        codonRange: {
+          start: 0,
+          end: 0
+        },
+        fullCodon: false
+      },
+      {
+        aminoAcid: getAA("aca"),
+        positionInCodon: 2,
+        aminoAcidIndex: 1,
+        sequenceIndex: 1,
+        codonRange: {
+          start: 1,
+          end: 3
+        },
+        fullCodon: true
+      },
+      {
+        aminoAcid: getAA("aca"),
+        positionInCodon: 1,
+        aminoAcidIndex: 1,
+        sequenceIndex: 2,
+        codonRange: {
+          start: 1,
+          end: 3
+        },
+        fullCodon: true
+      },
+      {
+        aminoAcid: getAA("aca"),
+        positionInCodon: 0,
+        aminoAcidIndex: 1,
+        sequenceIndex: 3,
+        codonRange: {
+          start: 1,
+          end: 3
+        },
+        fullCodon: true
+      },
+      {
+        aminoAcid: getAA("att"),
+        positionInCodon: 2,
+        aminoAcidIndex: 0,
+        sequenceIndex: 4,
+        codonRange: {
+          start: 4,
+          end: 6
+        },
+        fullCodon: true
+      },
+      {
+        aminoAcid: getAA("att"),
+        positionInCodon: 1,
+        aminoAcidIndex: 0,
+        sequenceIndex: 5,
+        codonRange: {
+          start: 4,
+          end: 6
+        },
+        fullCodon: true
+      },
+      {
+        aminoAcid: getAA("att"),
+        positionInCodon: 0,
+        aminoAcidIndex: 0,
+        sequenceIndex: 6,
+        codonRange: {
+          start: 4,
+          end: 6
+        },
+        fullCodon: true
+      }
+    ]);
+  });
+  it("< 1 amino acid long sequence", () => {
+    aaData = getAminoAcidDataForEachBaseOfDna("at", true);
+    assert.deepEqual(aaData, [
+      {
+        aminoAcid: getAA("xxx"),
+        positionInCodon: 0,
+        aminoAcidIndex: 0,
+        sequenceIndex: 0,
+        fullCodon: false,
+        codonRange: {
+          start: 0,
+          end: 1
+        }
+      },
+      {
+        aminoAcid: getAA("xxx"),
+        positionInCodon: 1,
+        aminoAcidIndex: 0,
+        sequenceIndex: 1,
+        fullCodon: false,
+        codonRange: {
+          start: 0,
+          end: 1
+        }
+      }
+    ]);
+  });
+  it("< 1 amino acid long sequence in reverse direction", () => {
+    aaData = getAminoAcidDataForEachBaseOfDna("at", false);
+    assert.deepEqual(aaData, [
+      {
+        aminoAcid: getAA("xxx"),
+        positionInCodon: 1,
+        aminoAcidIndex: 0,
+        sequenceIndex: 0,
+        fullCodon: false,
+        codonRange: {
+          start: 0,
+          end: 1
+        }
+      },
+      {
+        aminoAcid: getAA("xxx"),
+        positionInCodon: 0,
+        aminoAcidIndex: 0,
+        sequenceIndex: 1,
+        fullCodon: false,
+        codonRange: {
+          start: 0,
+          end: 1
+        }
+      }
+    ]);
+  });
+});

package/src/getAminoAcidFromSequenceTriplet.js

@@ -0,0 +1,22 @@
+import threeLetterSequenceStringToAminoAcidMap from "./threeLetterSequenceStringToAminoAcidMap";
+import proteinAlphabet from "./proteinAlphabet";
+import degenerateDnaToAminoAcidMap from "./degenerateDnaToAminoAcidMap";
+
+//tnrtodo: expand the threeLetterSequenceStringToAminoAcidMap mappings to include RNA characters.
+//currently stop bps aren't all mapped!
+export default function getAminoAcidFromSequenceTriplet(sequenceString) {
+  sequenceString = sequenceString.toLowerCase();
+  if (sequenceString.length !== 3) {
+    throw new Error("must pass a string of length 3");
+  }
+  const aa = threeLetterSequenceStringToAminoAcidMap[sequenceString];
+  if (aa) {
+    return aa;
+  }
+  const letter =
+    degenerateDnaToAminoAcidMap[
+      sequenceString.replace("x", "n") //replace x's with n's as those are equivalent dna chars
+    ] || "x";
+
+  return proteinAlphabet[letter.toUpperCase()];
+};

package/src/getAminoAcidStringFromSequenceString.js

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

package/src/getAminoAcidStringFromSequenceString.test.js

@@ -0,0 +1,18 @@
+import getAminoAcidStringFromSequenceString from "./getAminoAcidStringFromSequenceString";
+import assert from "assert";
+
+describe("getAminoAcidStringFromSequenceString", () => {
+  it("computes a aa string from dna", () => {
+    assert.equal("M", getAminoAcidStringFromSequenceString("atg"));
+    assert.equal("MM", getAminoAcidStringFromSequenceString("atgatg"));
+    assert.equal("MXM", getAminoAcidStringFromSequenceString("atgxxxatg"));
+    assert.equal("M.M", getAminoAcidStringFromSequenceString("atg...atg"));
+    assert.equal("M*M", getAminoAcidStringFromSequenceString("atgtrratg"));
+    assert.equal("M*M", getAminoAcidStringFromSequenceString("atgtaaatg"));
+    assert.equal("MB", getAminoAcidStringFromSequenceString("atgray"));
+    assert.equal("MX", getAminoAcidStringFromSequenceString("atgrRr"));
+    assert.equal("MM", getAminoAcidStringFromSequenceString("atgatg"));
+    assert.equal("M--", getAminoAcidStringFromSequenceString("atg------"));
+    assert.equal("", getAminoAcidStringFromSequenceString("at"));
+  });
+});

package/src/getCodonRangeForAASliver.js

@@ -0,0 +1,63 @@
+export default function getCodonRangeForAASliver(
+  aminoAcidPositionInSequence,
+  aminoAcidSliver,
+  AARepresentationOfTranslation,
+  relativeAAPositionInTranslation
+) {
+  const AASliverOneBefore =
+    AARepresentationOfTranslation[relativeAAPositionInTranslation - 1];
+  if (
+    AASliverOneBefore &&
+    AASliverOneBefore.aminoAcidIndex === aminoAcidSliver.aminoAcidIndex
+  ) {
+    const AASliverTwoBefore =
+      AARepresentationOfTranslation[relativeAAPositionInTranslation - 2];
+    if (
+      AASliverTwoBefore &&
+      AASliverTwoBefore.aminoAcidIndex === aminoAcidSliver.aminoAcidIndex
+    ) {
+      return {
+        start: aminoAcidPositionInSequence - 2,
+        end: aminoAcidPositionInSequence
+      };
+    } else {
+      if (aminoAcidSliver.fullCodon === true) {
+        return {
+          start: aminoAcidPositionInSequence - 1,
+          end: aminoAcidPositionInSequence + 1
+        };
+      } else {
+        return {
+          start: aminoAcidPositionInSequence - 1,
+          end: aminoAcidPositionInSequence
+        };
+      }
+    }
+  } else {
+    //no AASliver before with same index
+    if (aminoAcidSliver.fullCodon === true) {
+      //sliver is part of a full codon, so we know the codon will expand 2 more slivers ahead
+      return {
+        start: aminoAcidPositionInSequence,
+        end: aminoAcidPositionInSequence + 2
+      };
+    } else {
+      const AASliverOneAhead =
+        AARepresentationOfTranslation[relativeAAPositionInTranslation - 2];
+      if (
+        AASliverOneAhead &&
+        AASliverOneAhead.aminoAcidIndex === aminoAcidSliver.aminoAcidIndex
+      ) {
+        return {
+          start: aminoAcidPositionInSequence,
+          end: aminoAcidPositionInSequence + 1
+        };
+      } else {
+        return {
+          start: aminoAcidPositionInSequence,
+          end: aminoAcidPositionInSequence + 1
+        };
+      }
+    }
+  }
+};

package/src/getComplementAminoAcidStringFromSequenceString.js

@@ -0,0 +1,11 @@
+import getAminoAcidStringFromSequenceString from "./getAminoAcidStringFromSequenceString";
+
+export default function getComplementAminoAcidStringFromSequenceString(
+  sequenceString
+) {
+  const aaString = getAminoAcidStringFromSequenceString(sequenceString, true);
+  return aaString
+    .split("")
+    .reverse()
+    .join("");
+};

package/src/getComplementSequenceAndAnnotations.js

@@ -0,0 +1,20 @@
+import getComplementSequenceString from "./getComplementSequenceString";
+import tidyUpSequenceData from "./tidyUpSequenceData";
+
+
+import getSequenceDataBetweenRange from "./getSequenceDataBetweenRange";
+
+// ac.throw([ac.string,ac.bool],arguments);
+export default function getComplementSequenceAndAnnotations(
+  pSeqObj,
+  options = {}
+) {
+  const seqObj = tidyUpSequenceData(
+    getSequenceDataBetweenRange(pSeqObj, options.range),
+    options
+  );
+  const newSeqObj = Object.assign({}, seqObj, {
+    sequence: getComplementSequenceString(seqObj.sequence, seqObj.isRna)
+  });
+  return tidyUpSequenceData(newSeqObj, options);
+};

package/src/getComplementSequenceString.js

@@ -0,0 +1,19 @@
+import DNAComplementMap from "./DNAComplementMap";
+import { merge } from "lodash";
+
+
+// ac.throw([ac.string,ac.bool],arguments);
+export default function getComplementSequenceString(sequence, isRna) {
+  // ac.throw([ac.string],arguments);
+  let complementSeqString = "";
+  const complementMap = merge(DNAComplementMap, isRna ? { a: 'u', A: 'U'} : {a: 't', A: 'T'});
+  for (let i = 0; i < sequence.length; i++) {
+    let complementChar = complementMap[sequence[i]];
+    if (!complementChar) {
+      complementChar = sequence[i];
+      // throw new Error('trying to get the reverse compelement of an invalid base');
+    }
+    complementSeqString += complementChar;
+  }
+  return complementSeqString;
+};

package/src/getComplementSequenceString.test.js

@@ -0,0 +1,13 @@
+import getComplementSequenceString from "./getComplementSequenceString";
+
+import assert from "assert";
+
+describe('complement base should be shown correctly', () => {
+  it('complement base should be shown correctly for RNA sequence', () => {
+    assert.equal('UUA', getComplementSequenceString('AAU', true))
+  });
+
+  it('complement base should be shown correctly for DNA sequence', () => {
+    assert.equal('TTA', getComplementSequenceString('AAT'))
+  });
+});

package/src/getCutsiteType.js

@@ -0,0 +1,10 @@
+export default function getCutsiteType(restrictionEnzyme) {
+  const { topSnipOffset, bottomSnipOffset } = restrictionEnzyme;
+  if (topSnipOffset === bottomSnipOffset) {
+    return "blunt";
+  } else if (topSnipOffset < bottomSnipOffset) {
+    return "5' overhang";
+  } else {
+    return "3' overhang";
+  }
+};

package/src/getCutsitesFromSequence.js

@@ -0,0 +1,17 @@
+import cutSequenceByRestrictionEnzyme from "./cutSequenceByRestrictionEnzyme";
+
+export default function getCutsitesFromSequence(
+  sequence,
+  circular,
+  restrictionEnzymes
+) {
+  const cutsitesByName = {};
+  for (let i = 0; i < restrictionEnzymes.length; i++) {
+    const re = restrictionEnzymes[i];
+    const cutsites = cutSequenceByRestrictionEnzyme(sequence, circular, re);
+    if (cutsites.length) {
+      cutsitesByName[re.name] = cutsites;
+    }
+  }
+  return cutsitesByName;
+};

package/src/getDegenerateDnaStringFromAAString.js

@@ -0,0 +1,8 @@
+import aminoAcidToDegenerateDnaMap from "./aminoAcidToDegenerateDnaMap";
+
+export default function getDegenerateDnaStringFromAAString(aaString) {
+  return aaString
+    .split("")
+    .map(char => aminoAcidToDegenerateDnaMap[char.toLowerCase()] || "nnn")
+    .join("");
+};

package/src/getDegenerateRnaStringFromAAString.js

@@ -0,0 +1,8 @@
+import aminoAcidToDegenerateRnaMap from "./aminoAcidToDegenerateRnaMap";
+
+export default function getDegenerateRnaStringFromAAString(aaString) {
+  return aaString
+    .split("")
+    .map(char => aminoAcidToDegenerateRnaMap[char.toLowerCase()] || "nnn")
+    .join("");
+};