@teselagen/sequence-utils 0.1.22 → 0.1.24

package/src/proteinAlphabet.js

@@ -0,0 +1,257 @@
+const proteinAlphabet = {
+  A: {
+    value: "A",
+    name: "Alanine",
+    threeLettersName: "Ala",
+    hydrophobicity: 1.8,
+    colorByFamily: "#00FFFF",
+    color: "hsl(327.3, 100%, 69%)",
+    mass: 89.1
+  },
+  R: {
+    value: "R",
+    name: "Arginine",
+    threeLettersName: "Arg",
+    hydrophobicity: -4.5,
+    colorByFamily: "#FFC0CB",
+    color: "hsl(258.1, 100%, 69%)",
+    mass: 174.2
+  },
+  N: {
+    value: "N",
+    name: "Asparagine",
+    threeLettersName: "Asn",
+    hydrophobicity: -3.5,
+    colorByFamily: "#D3D3D3",
+    color: "hsl(268.9, 100%, 69%)",
+    mass: 132.1
+  },
+  D: {
+    value: "D",
+    name: "Aspartic acid",
+    threeLettersName: "Asp",
+    hydrophobicity: -3.5,
+    colorByFamily: "#EE82EE",
+    color: "hsl(268.9, 100%, 69%)",
+    mass: 133.1
+  },
+  C: {
+    value: "C",
+    name: "Cysteine",
+    threeLettersName: "Cys",
+    hydrophobicity: 2.5,
+    colorByFamily: "#FFFF00",
+    color: "hsl(335.1, 100%, 69%)",
+    mass: 121.2
+  },
+  E: {
+    value: "E",
+    name: "Glutamic acid",
+    threeLettersName: "Glu",
+    hydrophobicity: -3.5,
+    colorByFamily: "#EE82EE",
+    color: "hsl(268.9, 100%, 69%)",
+    mass: 147.1
+  },
+  Q: {
+    value: "Q",
+    name: "Glutamine",
+    threeLettersName: "Gln",
+    hydrophobicity: -3.5,
+    colorByFamily: "#D3D3D3",
+    color: "hsl(268.9, 100%, 69%)",
+    mass: 146.2
+  },
+  G: {
+    value: "G",
+    name: "Glycine",
+    threeLettersName: "Gly",
+    hydrophobicity: -0.4,
+    colorByFamily: "#00FFFF",
+    color: "hsl(303.1, 100%, 69%)",
+    mass: 75.1
+  },
+  H: {
+    value: "H",
+    name: "Histidine",
+    threeLettersName: "His",
+    hydrophobicity: -3.2,
+    colorByFamily: "#FFC0CB",
+    color: "hsl(272.2, 100%, 69%)",
+    mass: 155.2
+  },
+  I: {
+    value: "I",
+    name: "Isoleucine ",
+    threeLettersName: "Ile",
+    hydrophobicity: 4.5,
+    colorByFamily: "#00FFFF",
+    color: "hsl(356.9, 100%, 69%)",
+    mass: 131.2
+  },
+  L: {
+    value: "L",
+    name: "Leucine",
+    threeLettersName: "Leu",
+    hydrophobicity: 3.8,
+    colorByFamily: "#00FFFF",
+    color: "hsl(349.4, 100%, 69%)",
+    mass: 131.2
+  },
+  K: {
+    value: "K",
+    name: "Lysine",
+    threeLettersName: "Lys",
+    hydrophobicity: -3.9,
+    colorByFamily: "#FFC0CB",
+    color: "hsl(264.7, 100%, 69%)",
+    mass: 146.2
+  },
+  M: {
+    value: "M",
+    name: "Methionine",
+    threeLettersName: "Met",
+    hydrophobicity: 1.9,
+    colorByFamily: "#FFFF00",
+    color: "hsl(328.5, 100%, 69%)",
+    mass: 149.2
+  },
+  F: {
+    value: "F",
+    name: "Phenylalanine",
+    threeLettersName: "Phe",
+    hydrophobicity: 2.8,
+    colorByFamily: "#FFA500",
+    color: "hsl(338.4, 100%, 69%)",
+    mass: 165.2
+  },
+  P: {
+    value: "P",
+    name: "Proline",
+    threeLettersName: "Pro",
+    hydrophobicity: -1.6,
+    colorByFamily: "#00FFFF",
+    color: "hsl(289.9, 100%, 69%)",
+    mass: 115.1
+  },
+  S: {
+    value: "S",
+    name: "Serine",
+    threeLettersName: "Ser",
+    hydrophobicity: -0.8,
+    colorByFamily: "#90EE90",
+    color: "hsl(298.6, 100%, 69%)",
+    mass: 105.1
+  },
+  T: {
+    value: "T",
+    name: "Threonine",
+    threeLettersName: "Thr",
+    hydrophobicity: -0.7,
+    colorByFamily: "#90EE90",
+    color: "hsl(299.8, 100%, 69%)",
+    mass: 119.1
+  },
+  U: {
+    value: "U",
+    name: "Selenocysteine",
+    threeLettersName: "Sec",
+    colorByFamily: "#FF0000",
+    color: "hsl(0, 100%, 69%)",
+    mass: 168.1
+  },
+  W: {
+    value: "W",
+    name: "Tryptophan",
+    threeLettersName: "Trp",
+    hydrophobicity: -0.9,
+    colorByFamily: "#FFA500",
+    color: "hsl(297.6, 100%, 69%)",
+    mass: 204.2
+  },
+  Y: {
+    value: "Y",
+    name: "Tyrosine",
+    threeLettersName: "Tyr",
+    hydrophobicity: -1.3,
+    colorByFamily: "#FFA500",
+    color: "hsl(293.2, 100%, 69%)",
+    mass: 181.2
+  },
+  V: {
+    value: "V",
+    name: "Valine",
+    threeLettersName: "Val",
+    hydrophobicity: 4.2,
+    colorByFamily: "#00FFFF",
+    color: "hsl(353.6, 100%, 69%)",
+    mass: 117.1
+  },
+  "*": {
+    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.js

@@ -0,0 +1,13 @@
+export default function rotateBpsToPosition(
+  bps,
+  caretPosition,
+) {
+  return arrayRotate(bps.split(""), caretPosition).join("")
+};
+
+
+function arrayRotate(arr, count) {
+  count -= arr.length * Math.floor(count / arr.length)
+  arr.push.apply(arr, arr.splice(0, count))
+  return arr
+}

package/src/rotateBpsToPosition.test.js

@@ -0,0 +1,6 @@
+import rotateBpsToPosition from './rotateBpsToPosition';
+describe('rotateBpsToPosition', () => {
+    it('should rotate Bps To Position correctly ', () => {
+        expect(rotateBpsToPosition("atgaccc",4)).toEqual("cccatga")
+    })
+})

package/src/rotateSequenceDataToPosition.js

@@ -0,0 +1,48 @@
+import {map} from "lodash";
+import {adjustRangeToRotation} from "@teselagen/range-utils";
+import tidyUpSequenceData from "./tidyUpSequenceData";
+import {modifiableTypes} from "./annotationTypes";
+import rotateBpsToPosition from "./rotateBpsToPosition";
+
+export default function rotateSequenceDataToPosition(
+  sequenceData,
+  caretPosition,
+  options
+) {
+  const newSequenceData = tidyUpSequenceData(sequenceData, 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],
+      caretPosition,
+      newSequenceData.sequence.length
+    );
+  });
+  return newSequenceData;
+};
+
+function adjustAnnotationsToRotation(
+  annotationsToBeAdjusted,
+  positionToRotateTo,
+  maxLength
+) {
+  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/rotateSequenceDataToPosition.test.js

@@ -0,0 +1,71 @@
+import rotateSequenceDataToPosition from "./rotateSequenceDataToPosition";
+describe("rotateSequenceDataToPosition", () => {
+  it("should rotate vanilla sequence data correctly", () => {
+    const newData = rotateSequenceDataToPosition(
+      {
+        //         0123456
+        sequence: "atgaccc"
+      },
+      4
+    );
+    expect(newData.sequence).toEqual("cccatga");
+  });
+  it("should rotate sequence data with features correctly", () => {
+    const newData = rotateSequenceDataToPosition(
+      {
+        //         0123456
+        sequence: "atgaccc",
+        features: [
+          {
+            start: 4,
+            end: 4
+          },
+          {
+            start: 1,
+            end: 0
+          },
+          {
+            start: 2,
+            end: 6,
+            locations: [
+              {
+                start: 2,
+                end: 3
+              },
+              {
+                start: 4,
+                end: 6
+              }
+            ]
+          }
+        ]
+      },
+      4
+    );
+    expect(newData.sequence).toEqual("cccatga");
+    expect(newData.features).toMatchObject([
+      {
+        start: 0,
+        end: 0
+      },
+      {
+        start: 4,
+        end: 3
+      },
+      {
+        start: 5,
+        end: 2,
+        locations: [
+          {
+            start: 5,
+            end: 6
+          },
+          {
+            start: 0,
+            end: 2
+          }
+        ]
+      }
+    ]);
+  });
+});

package/src/shiftAnnotationsByLen.js

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

package/src/threeLetterSequenceStringToAminoAcidMap.js

@@ -0,0 +1,106 @@
+import proteinAlphabet from "./proteinAlphabet";
+
+const threeLetterSequenceStringToAminoAcidMap = {
+  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["*"],
+  "...": proteinAlphabet["."],
+  "---": proteinAlphabet["-"]
+};
+
+export default threeLetterSequenceStringToAminoAcidMap;

package/src/tidyUpAnnotation.js

@@ -0,0 +1,182 @@
+import {cloneDeep, get, some} from "lodash";
+import {getFeatureToColorMap, getFeatureTypes} from "./featureTypesAndColors";
+import shortid from "shortid";
+
+export default function tidyUpAnnotation(
+  _annotation,
+  {
+    sequenceData = {},
+    convertAnnotationsFromAAIndices,
+    annotationType,
+    provideNewIdsForAnnotations,
+    doNotProvideIdsForAnnotations,
+    messages = [],
+    mutative,
+    allowNonStandardGenbankTypes,
+    featureTypes
+  }
+) {
+  const { size, circular, isProtein } = sequenceData;
+  if (!_annotation || typeof _annotation !== "object") {
+    messages.push("Invalid annotation detected and removed");
+    return false;
+  }
+  let annotation = _annotation;
+  if (!mutative) {
+    annotation = cloneDeep(_annotation);
+  }
+  annotation.annotationTypePlural = annotationType;
+
+  if (!annotation.name || typeof annotation.name !== "string") {
+    messages.push(
+      'Unable to detect valid name for annotation, setting name to "Untitled annotation"'
+    );
+    annotation.name = "Untitled annotation";
+  }
+  if (provideNewIdsForAnnotations) {
+    annotation.id = shortid();
+  }
+  if (!annotation.id && annotation.id !== 0 && !doNotProvideIdsForAnnotations) {
+    annotation.id = shortid();
+    messages.push(
+      "Unable to detect valid ID for annotation, setting ID to " + annotation.id
+    );
+  }
+
+  //run this for the annotation itself
+  coerceLocation({
+    isProtein,
+    location: annotation,
+    convertAnnotationsFromAAIndices,
+    size,
+    messages,
+    circular,
+    name: annotation.name
+  });
+  //and for each location
+  annotation.locations &&
+    annotation.locations.forEach(location => {
+      coerceLocation({
+        isProtein,
+        location,
+        convertAnnotationsFromAAIndices,
+        size,
+        messages,
+        circular,
+        name: annotation.name
+      });
+    });
+
+  if (
+    isProtein ||
+    annotation.forward === true ||
+    annotation.forward === "true" ||
+    annotation.strand === 1 ||
+    annotation.strand === "1" ||
+    annotation.strand === "+"
+  ) {
+    annotation.forward = true;
+    annotation.strand = 1;
+  } else {
+    annotation.forward = false;
+    annotation.strand = -1;
+  }
+  if (
+    !annotation.type ||
+    typeof annotation.type !== "string" ||
+    !some(featureTypes || getFeatureTypes(), featureType => {
+      if (featureType.toLowerCase() === annotation.type.toLowerCase()) {
+        annotation.type = featureType; //this makes sure the annotation.type is being set to the exact value of the accepted featureType
+        return true;
+      }
+      if (
+        allowNonStandardGenbankTypes ||
+        (typeof window !== "undefined" &&
+          get(window, "tg_allowNonStandardGenbankTypes")) ||
+        (typeof global !== "undefined" &&
+          get(global, "tg_allowNonStandardGenbankTypes"))
+      )
+        return true;
+      return false;
+    })
+  ) {
+    messages.push(
+      "Invalid annotation type detected:  " +
+        annotation.type +
+        " for " +
+        annotation.name +
+        ". set type to misc_feature"
+    );
+    annotation.type = "misc_feature";
+  }
+  if (annotation.notes && typeof annotation.notes === "string") {
+    try {
+      annotation.notes = JSON.parse(annotation.notes);
+    } catch (error) {
+      console.info(
+        `warning 33y00a0912 - couldn't parse notes for ${annotation.name ||
+          ""} ${annotation.notes}:`,
+        error
+      );
+    }
+  }
+
+  if (!annotation.color) {
+    annotation.color = getFeatureToColorMap()[annotation.type];
+  }
+  return annotation;
+};
+
+function coerceLocation({
+  location,
+  convertAnnotationsFromAAIndices,
+  size,
+  isProtein,
+  messages,
+  circular,
+  name
+}) {
+  location.start = parseInt(location.start, 10);
+  location.end = parseInt(location.end, 10);
+
+  if (convertAnnotationsFromAAIndices) {
+    location.start = location.start * 3;
+    location.end = location.end * 3 + 2;
+  }
+  if (
+    location.start < 0 ||
+    !(location.start <= size - 1) ||
+    location.start > size - 1
+  ) {
+    messages.push(
+      "Invalid annotation start: " +
+        location.start +
+        " detected for " +
+        location.name +
+        " and set to size: " +
+        size
+    ); //setting it to 0 internally, but users will see it as 1
+    location.start = size - (isProtein ? 3 : 1);
+  }
+  if (
+    location.end < 0 ||
+    !(location.end <= size - 1) ||
+    location.end > size - 1
+  ) {
+    messages.push(
+      "Invalid annotation end:  " +
+        location.end +
+        " detected for " +
+        location.name +
+        " and set to seq size: " +
+        size
+    ); //setting it to 0 internally, but users will see it as 1
+    location.end = size - 1;
+  }
+  if (location.start > location.end && circular === false) {
+    messages.push(
+      "Invalid circular annotation detected for " + name + ". end set to 1"
+    ); //setting it to 0 internally, but users will see it as 1
+    location.end = size;
+  }
+}