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

package/src/proteinAlphabet.ts

@@ -0,0 +1,271 @@
+const proteinAlphabet = {
+  A: {
+    value: "A",
+    name: "Alanine",
+    threeLettersName: "Ala",
+    hydrophobicity: 1.8,
+    colorByFamily: "#00FFFF",
+    color: "hsl(327.3, 100%, 69%)",
+    mass: 71.0779
+  },
+  R: {
+    value: "R",
+    name: "Arginine",
+    threeLettersName: "Arg",
+    hydrophobicity: -4.5,
+    colorByFamily: "#FFC0CB",
+    color: "hsl(258.1, 100%, 69%)",
+    mass: 156.18568
+  },
+
+  N: {
+    value: "N",
+    name: "Asparagine",
+    threeLettersName: "Asn",
+    hydrophobicity: -3.5,
+    colorByFamily: "#D3D3D3",
+    color: "hsl(268.9, 100%, 69%)",
+    mass: 114.10264
+  },
+  D: {
+    value: "D",
+    name: "Aspartic acid",
+    threeLettersName: "Asp",
+    hydrophobicity: -3.5,
+    colorByFamily: "#EE82EE",
+    color: "hsl(268.9, 100%, 69%)",
+    mass: 115.0874
+  },
+  C: {
+    value: "C",
+    name: "Cysteine",
+    threeLettersName: "Cys",
+    hydrophobicity: 2.5,
+    colorByFamily: "#FFFF00",
+    color: "hsl(335.1, 100%, 69%)",
+    mass: 103.1429
+  },
+
+  E: {
+    value: "E",
+    name: "Glutamic acid",
+    threeLettersName: "Glu",
+    hydrophobicity: -3.5,
+    colorByFamily: "#EE82EE",
+    color: "hsl(268.9, 100%, 69%)",
+    mass: 129.11398
+  },
+  Q: {
+    value: "Q",
+    name: "Glutamine",
+    threeLettersName: "Gln",
+    hydrophobicity: -3.5,
+    colorByFamily: "#D3D3D3",
+    color: "hsl(268.9, 100%, 69%)",
+    mass: 128.12922
+  },
+  G: {
+    value: "G",
+    name: "Glycine",
+    threeLettersName: "Gly",
+    hydrophobicity: -0.4,
+    colorByFamily: "#00FFFF",
+    color: "hsl(303.1, 100%, 69%)",
+    mass: 57.05132
+  },
+
+  H: {
+    value: "H",
+    name: "Histidine",
+    threeLettersName: "His",
+    hydrophobicity: -3.2,
+    colorByFamily: "#FFC0CB",
+    color: "hsl(272.2, 100%, 69%)",
+    mass: 137.13928
+  },
+
+  I: {
+    value: "I",
+    name: "Isoleucine ",
+    threeLettersName: "Ile",
+    hydrophobicity: 4.5,
+    colorByFamily: "#00FFFF",
+    color: "hsl(356.9, 100%, 69%)",
+    mass: 113.15764
+  },
+  L: {
+    value: "L",
+    name: "Leucine",
+    threeLettersName: "Leu",
+    hydrophobicity: 3.8,
+    colorByFamily: "#00FFFF",
+    color: "hsl(349.4, 100%, 69%)",
+    mass: 113.15764
+  },
+  K: {
+    value: "K",
+    name: "Lysine",
+    threeLettersName: "Lys",
+    hydrophobicity: -3.9,
+    colorByFamily: "#FFC0CB",
+    color: "hsl(264.7, 100%, 69%)",
+    mass: 128.17228
+  },
+
+  O: {
+    value: "O",
+    name: "Pyrrolysine",
+    threeLettersName: "Pyl",
+    colorByFamily: "#FFC0CB",
+    color: "hsl(264.7, 100%, 69%)",
+    mass: 255.313
+  },
+
+  M: {
+    value: "M",
+    name: "Methionine",
+    threeLettersName: "Met",
+    hydrophobicity: 1.9,
+    colorByFamily: "#FFFF00",
+    color: "hsl(328.5, 100%, 69%)",
+    mass: 131.19606
+  },
+  F: {
+    value: "F",
+    name: "Phenylalanine",
+    threeLettersName: "Phe",
+    hydrophobicity: 2.8,
+    colorByFamily: "#FFA500",
+    color: "hsl(338.4, 100%, 69%)",
+    mass: 147.17386
+  },
+  P: {
+    value: "P",
+    name: "Proline",
+    threeLettersName: "Pro",
+    hydrophobicity: -1.6,
+    colorByFamily: "#00FFFF",
+    color: "hsl(289.9, 100%, 69%)",
+    mass: 97.11518
+  },
+  S: {
+    value: "S",
+    name: "Serine",
+    threeLettersName: "Ser",
+    hydrophobicity: -0.8,
+    colorByFamily: "#90EE90",
+    color: "hsl(298.6, 100%, 69%)",
+    mass: 87.0773
+  },
+  T: {
+    value: "T",
+    name: "Threonine",
+    threeLettersName: "Thr",
+    hydrophobicity: -0.7,
+    colorByFamily: "#90EE90",
+    color: "hsl(299.8, 100%, 69%)",
+    mass: 101.10388
+  },
+  U: {
+    value: "U",
+    name: "Selenocysteine",
+    threeLettersName: "Sec",
+    colorByFamily: "#FF0000",
+    color: "hsl(0, 100%, 69%)",
+    mass: 150.3079
+  },
+  W: {
+    value: "W",
+    name: "Tryptophan",
+    threeLettersName: "Trp",
+    hydrophobicity: -0.9,
+    colorByFamily: "#FFA500",
+    color: "hsl(297.6, 100%, 69%)",
+    mass: 186.2099
+  },
+  Y: {
+    value: "Y",
+    name: "Tyrosine",
+    threeLettersName: "Tyr",
+    hydrophobicity: -1.3,
+    colorByFamily: "#FFA500",
+    color: "hsl(293.2, 100%, 69%)",
+    mass: 163.17326
+  },
+  V: {
+    value: "V",
+    name: "Valine",
+    threeLettersName: "Val",
+    hydrophobicity: 4.2,
+    colorByFamily: "#00FFFF",
+    color: "hsl(353.6, 100%, 69%)",
+    mass: 99.13106
+  },
+  "*": {
+    value: "*",
+    name: "Stop",
+    threeLettersName: "Stop",
+    colorByFamily: "#FF0000",
+    color: "hsl(0, 100%, 69%)",
+    mass: 0
+  },
+  ".": {
+    //tnr: this is actually a deletion/gap character (previously we had this as a stop character which is incorrect) https://www.dnabaser.com/articles/IUPAC%20ambiguity%20codes.html
+    value: ".",
+    name: "Gap",
+    threeLettersName: "Gap",
+    colorByFamily: "#FF0000",
+    color: "hsl(0, 100%, 69%)",
+    mass: 0
+  },
+  "-": {
+    value: "-",
+    name: "Gap",
+    threeLettersName: "Gap",
+    colorByFamily: "#FF0000",
+    color: "hsl(0, 100%, 69%)",
+    mass: 0
+  },
+  B: {
+    value: "B",
+    threeLettersName: "ND",
+    colorByFamily: "#D3D3D3",
+    color: "hsl(268.9, 100%, 69%)",
+    isAmbiguous: true,
+    name: "B",
+    aliases: "ND",
+    mass: 0
+  },
+  J: {
+    value: "J",
+    threeLettersName: "IL",
+    colorByFamily: "#00FFFF",
+    color: "hsl(352, 100%, 69%)",
+    isAmbiguous: true,
+    name: "J",
+    aliases: "IL",
+    mass: 0
+  },
+  X: {
+    value: "X",
+    threeLettersName: "ACDEFGHIKLMNPQRSTVWY",
+    colorByFamily: "#FFFFFF",
+    color: "hsl(60, 100%, 69%)",
+    isAmbiguous: true,
+    name: "X",
+    aliases: "ACDEFGHIKLMNPQRSTVWY",
+    mass: 0
+  },
+  Z: {
+    value: "Z",
+    threeLettersName: "QE",
+    colorByFamily: "#D3D3D3",
+    color: "hsl(268.9, 100%, 69%)",
+    isAmbiguous: true,
+    name: "Z",
+    aliases: "QE",
+    mass: 0
+  }
+};
+
+export default proteinAlphabet;

package/src/rotateBpsToPosition.ts

@@ -0,0 +1,12 @@
+export default function rotateBpsToPosition(
+  bps: string,
+  caretPosition: number
+) {
+  return arrayRotate(bps.split(""), caretPosition).join("");
+}
+
+function arrayRotate<T>(arr: T[], count: number): T[] {
+  count -= arr.length * Math.floor(count / arr.length);
+  arr.push(...arr.splice(0, count));
+  return arr;
+}

package/src/rotateSequenceDataToPosition.ts

@@ -0,0 +1,54 @@
+import { map } from "lodash-es";
+import { adjustRangeToRotation } from "@teselagen/range-utils";
+import tidyUpSequenceData, {
+  TidyUpSequenceDataOptions
+} from "./tidyUpSequenceData";
+import { modifiableTypes } from "./annotationTypes";
+import rotateBpsToPosition from "./rotateBpsToPosition";
+import { SequenceData, Annotation } from "./types";
+
+export default function rotateSequenceDataToPosition(
+  sequenceData: SequenceData,
+  caretPosition: number,
+  options: TidyUpSequenceDataOptions = {}
+) {
+  const newSequenceData = tidyUpSequenceData(sequenceData, {
+    doNotRemoveInvalidChars: true,
+    ...options
+  });
+
+  //update the sequence
+  newSequenceData.sequence = rotateBpsToPosition(
+    newSequenceData.sequence,
+    caretPosition
+  );
+
+  //handle the insert
+  modifiableTypes.forEach(annotationType => {
+    //update the annotations:
+    //handle the delete if necessary
+    newSequenceData[annotationType] = adjustAnnotationsToRotation(
+      newSequenceData[annotationType] as Annotation[],
+      caretPosition,
+      newSequenceData.sequence.length
+    );
+  });
+  return newSequenceData;
+}
+
+function adjustAnnotationsToRotation(
+  annotationsToBeAdjusted: Annotation[],
+  positionToRotateTo: number,
+  maxLength: number
+) {
+  return map(annotationsToBeAdjusted, annotation => {
+    return {
+      ...adjustRangeToRotation(annotation, positionToRotateTo, maxLength),
+      locations: annotation.locations
+        ? annotation.locations.map(location =>
+            adjustRangeToRotation(location, positionToRotateTo, maxLength)
+          )
+        : undefined
+    };
+  }).filter(range => !!range); //filter any fully deleted ranges
+}

package/src/shiftAnnotationsByLen.ts

@@ -0,0 +1,24 @@
+import { modifiableTypes } from "./annotationTypes";
+import adjustAnnotationsToInsert from "./adjustAnnotationsToInsert";
+import { SequenceData } from "./types";
+
+export default function shiftAnnotationsByLen({
+  seqData,
+  caretPosition,
+  insertLength
+}: {
+  seqData: SequenceData;
+  caretPosition: number;
+  insertLength: number;
+}) {
+  modifiableTypes.forEach(annotationType => {
+    const existingAnnotations = seqData[annotationType];
+    if (existingAnnotations) {
+      seqData[annotationType] = adjustAnnotationsToInsert(
+        existingAnnotations,
+        caretPosition,
+        insertLength
+      );
+    }
+  });
+}

package/src/threeLetterSequenceStringToAminoAcidMap.ts

@@ -0,0 +1,198 @@
+import proteinAlphabet from "./proteinAlphabet";
+
+const initThreeLetterSequenceStringToAminoAcidMap: Record<
+  string,
+  {
+    value: string;
+    name: string;
+    threeLettersName: string;
+    hydrophobicity?: number;
+    colorByFamily: string;
+    color: string;
+    mass: number;
+    isAmbiguous?: boolean;
+    aliases?: string;
+  }
+> = {
+  gct: proteinAlphabet.A,
+  gcc: proteinAlphabet.A,
+  gca: proteinAlphabet.A,
+  gcg: proteinAlphabet.A,
+  gcu: proteinAlphabet.A,
+  cgt: proteinAlphabet.R,
+  cgc: proteinAlphabet.R,
+  cga: proteinAlphabet.R,
+  cgg: proteinAlphabet.R,
+  aga: proteinAlphabet.R,
+  agg: proteinAlphabet.R,
+  cgu: proteinAlphabet.R,
+  aat: proteinAlphabet.N,
+  aac: proteinAlphabet.N,
+  aau: proteinAlphabet.N,
+  gat: proteinAlphabet.D,
+  gac: proteinAlphabet.D,
+  gau: proteinAlphabet.D,
+  tgt: proteinAlphabet.C,
+  tgc: proteinAlphabet.C,
+  ugu: proteinAlphabet.C,
+  ugc: proteinAlphabet.C,
+  gaa: proteinAlphabet.E,
+  gag: proteinAlphabet.E,
+  caa: proteinAlphabet.Q,
+  cag: proteinAlphabet.Q,
+  ggt: proteinAlphabet.G,
+  ggc: proteinAlphabet.G,
+  gga: proteinAlphabet.G,
+  ggg: proteinAlphabet.G,
+  ggu: proteinAlphabet.G,
+  cat: proteinAlphabet.H,
+  cac: proteinAlphabet.H,
+  cau: proteinAlphabet.H,
+  att: proteinAlphabet.I,
+  atc: proteinAlphabet.I,
+  ata: proteinAlphabet.I,
+  auu: proteinAlphabet.I,
+  auc: proteinAlphabet.I,
+  aua: proteinAlphabet.I,
+  ctt: proteinAlphabet.L,
+  ctc: proteinAlphabet.L,
+  cta: proteinAlphabet.L,
+  ctg: proteinAlphabet.L,
+  tta: proteinAlphabet.L,
+  ttg: proteinAlphabet.L,
+  cuu: proteinAlphabet.L,
+  cuc: proteinAlphabet.L,
+  cua: proteinAlphabet.L,
+  cug: proteinAlphabet.L,
+  uua: proteinAlphabet.L,
+  uug: proteinAlphabet.L,
+  aaa: proteinAlphabet.K,
+  aag: proteinAlphabet.K,
+  atg: proteinAlphabet.M,
+  aug: proteinAlphabet.M,
+  ttt: proteinAlphabet.F,
+  ttc: proteinAlphabet.F,
+  uuu: proteinAlphabet.F,
+  uuc: proteinAlphabet.F,
+  cct: proteinAlphabet.P,
+  ccc: proteinAlphabet.P,
+  cca: proteinAlphabet.P,
+  ccg: proteinAlphabet.P,
+  ccu: proteinAlphabet.P,
+  tct: proteinAlphabet.S,
+  tcc: proteinAlphabet.S,
+  tca: proteinAlphabet.S,
+  tcg: proteinAlphabet.S,
+  agt: proteinAlphabet.S,
+  agc: proteinAlphabet.S,
+  ucu: proteinAlphabet.S,
+  ucc: proteinAlphabet.S,
+  uca: proteinAlphabet.S,
+  ucg: proteinAlphabet.S,
+  agu: proteinAlphabet.S,
+  act: proteinAlphabet.T,
+  acc: proteinAlphabet.T,
+  aca: proteinAlphabet.T,
+  acg: proteinAlphabet.T,
+  acu: proteinAlphabet.T,
+  tgg: proteinAlphabet.W,
+  ugg: proteinAlphabet.W,
+  tat: proteinAlphabet.Y,
+  tac: proteinAlphabet.Y,
+  uau: proteinAlphabet.Y,
+  uac: proteinAlphabet.Y,
+  gtt: proteinAlphabet.V,
+  gtc: proteinAlphabet.V,
+  gta: proteinAlphabet.V,
+  gtg: proteinAlphabet.V,
+  guu: proteinAlphabet.V,
+  guc: proteinAlphabet.V,
+  gua: proteinAlphabet.V,
+  gug: proteinAlphabet.V,
+  taa: proteinAlphabet["*"],
+  tag: proteinAlphabet["*"],
+  tga: proteinAlphabet["*"],
+  uaa: proteinAlphabet["*"],
+  uag: proteinAlphabet["*"],
+  uga: proteinAlphabet["*"],
+  "...": proteinAlphabet["."],
+  "---": proteinAlphabet["-"]
+};
+
+// IUPAC nucleotide codes (DNA/RNA) with U awareness
+const IUPAC: Record<string, string[]> = {
+  A: ["A"],
+  C: ["C"],
+  G: ["G"],
+  T: ["T"],
+  U: ["U"],
+
+  R: ["A", "G"],
+  Y: ["C", "T", "U"],
+  K: ["G", "T", "U"],
+  M: ["A", "C"],
+  S: ["G", "C"],
+  W: ["A", "T", "U"],
+  B: ["C", "G", "T", "U"],
+  D: ["A", "G", "T", "U"],
+  H: ["A", "C", "T", "U"],
+  V: ["A", "C", "G"],
+  N: ["A", "C", "G", "T", "U"],
+  X: ["A", "C", "G", "T", "U"]
+};
+
+function expandAndResolve(threeLetterCodon: string) {
+  const chars = threeLetterCodon.toUpperCase().split("");
+  const picks = chars.map(c => IUPAC[c] || [c]);
+
+  let allPossibleThreeLetterCodons = [""];
+  for (const set of picks) {
+    const next = [];
+    for (const prefix of allPossibleThreeLetterCodons)
+      for (const b of set) next.push(prefix + b);
+    allPossibleThreeLetterCodons = next;
+  }
+  let foundAminoAcid = null;
+  for (const codon of allPossibleThreeLetterCodons) {
+    const lowerCodon = codon.toLowerCase();
+    const aminoAcidObj =
+      initThreeLetterSequenceStringToAminoAcidMap[lowerCodon] ??
+      initThreeLetterSequenceStringToAminoAcidMap[
+        lowerCodon.replace(/u/g, "t")
+      ] ??
+      initThreeLetterSequenceStringToAminoAcidMap[
+        lowerCodon.replace(/t/g, "u")
+      ];
+    if (aminoAcidObj) {
+      if (!foundAminoAcid) {
+        foundAminoAcid = aminoAcidObj;
+      } else if (foundAminoAcid.value !== aminoAcidObj.value) {
+        return null;
+      }
+    } else {
+      return null;
+    }
+  }
+  return foundAminoAcid;
+}
+
+function getCodonToAminoAcidMap() {
+  const map = initThreeLetterSequenceStringToAminoAcidMap;
+  // generate all IUPAC 3-mers
+  const codes = Object.keys(IUPAC);
+  for (const a of codes)
+    for (const b of codes)
+      for (const c of codes) {
+        const codon = a + b + c;
+        const lowerCodon = codon.toLowerCase();
+        if (map[lowerCodon]) continue;
+        const aminoAcidObj = expandAndResolve(codon);
+        if (aminoAcidObj) map[lowerCodon] = aminoAcidObj;
+      }
+
+  return map;
+}
+
+const threeLetterSequenceStringToAminoAcidMap = getCodonToAminoAcidMap();
+
+export default threeLetterSequenceStringToAminoAcidMap;