@teselagen/sequence-utils 0.1.22 → 0.1.23

package/src/deleteSequenceDataAtRange.test.js

@@ -0,0 +1,146 @@
+//tnr: half finished test.
+
+
+import chai from "chai";
+
+import {getRangeLength} from "@teselagen/range-utils";
+import {cloneDeep} from "lodash";
+import chaiSubset from "chai-subset";
+
+import deleteSequenceDataAtRange from "./deleteSequenceDataAtRange";
+
+chai.should();
+chai.use(chaiSubset);
+
+describe("deleteSequenceDataAtRange", () => {
+  it("Deletes everything if the range spans the whole sequence", () => {
+    const existingSequence = {
+      sequence: "atagatag"
+    };
+    const range = { start: 0, end: 7 };
+    const postDeleteSeqData = deleteSequenceDataAtRange(existingSequence, range);
+    postDeleteSeqData.sequence.length.should.equal(
+      existingSequence.sequence.length - getRangeLength(range)
+    );
+  });
+  it("Deletes everything if the range spans the whole sequence (circular selection)", () => {
+    const existingSequence = {
+      sequence: "atagatag"
+    };
+    const range = { start: 4, end: 3 };
+    const postDeleteSeqData = deleteSequenceDataAtRange(existingSequence, range);
+    postDeleteSeqData.sequence.length.should.equal(
+      existingSequence.sequence.length -
+        getRangeLength(range, existingSequence.sequence.length)
+    );
+  });
+  it("Delete characters at correct range", () => {
+    const existingSequence = {
+      sequence: "atagatag"
+    };
+    const range = { start: 3, end: 5 };
+    const postDeleteSeqData = deleteSequenceDataAtRange(existingSequence, range);
+    postDeleteSeqData.sequence.length.should.equal(
+      existingSequence.sequence.length - getRangeLength(range)
+    );
+  });
+  it("does not mutate the original sequence", () => {
+    const existingSequence = {
+      sequence: "atagatag",
+      features: {
+        "1": {
+          start: 7,
+          end: 7
+        }
+      }
+    };
+    const clonedExistingSeq = cloneDeep(existingSequence);
+    const range = { start: 3, end: 5 };
+    const postDeleteSeqData = deleteSequenceDataAtRange(existingSequence, range);
+    existingSequence.should.deep.equal(clonedExistingSeq);
+    postDeleteSeqData.sequence.length.should.equal(
+      existingSequence.sequence.length - getRangeLength(range)
+    );
+  });
+  it("Handles a non valid range by returning the original sequence", () => {
+    const existingSequence = {
+      sequence: "atgagagaga",
+
+      features: [
+        {
+          start: 0,
+          end: 9,
+          locations: [
+            { start: 0, end: 2 },
+            { start: 4, end: 9 }
+          ]
+        }
+      ]
+    };
+    const range = { start: -1, end: -1 };
+    const postDeleteSeqData = deleteSequenceDataAtRange(existingSequence, range);
+    postDeleteSeqData.should.containSubset({
+      sequence: "atgagagaga",
+      features: [
+        {
+          start: 0,
+          end: 9,
+          locations: [
+            { start: 0, end: 2 },
+            { start: 4, end: 9 }
+          ]
+        }
+      ]
+    });
+    postDeleteSeqData.features.length.should.equal(1);
+  });
+  it("Delete characters and features (with joined locations) at correct range", () => {
+    const existingSequence = {
+      sequence: "atgagagaga",
+      features: [
+        {
+          start: 0,
+          end: 9,
+          locations: [
+            { start: 0, end: 2 },
+            { start: 3, end: 7 },
+            { start: 9, end: 9 }
+          ]
+        }
+      ]
+    };
+    const postDeleteSeqData = deleteSequenceDataAtRange(existingSequence, {
+      start: 3,
+      end: 7
+    });
+    postDeleteSeqData.should.containSubset({
+      sequence: "atgga",
+      features: [
+        {
+          start: 0,
+          end: 4,
+          locations: [
+            { start: 0, end: 2 },
+            { start: 4, end: 4 }
+          ]
+        }
+      ]
+    });
+    postDeleteSeqData.features.length.should.equal(1);
+  });
+  it("Moves annotations when delete occurs before annotation", () => {
+    const existingSequence = {
+      sequence: "atgagagaga",
+      parts: [{ start: 5, end: 9 }]
+    };
+    const postDeleteSeqData = deleteSequenceDataAtRange(existingSequence, {
+      start: 3,
+      end: 3
+    });
+    postDeleteSeqData.should.containSubset({
+      sequence: "atggagaga",
+      parts: [{ start: 4, end: 8 }]
+    });
+    postDeleteSeqData.parts.length.should.equal(1);
+  });
+});

package/src/diffUtils.js

@@ -0,0 +1,64 @@
+import { cloneDeep, forEach } from 'lodash';
+import {
+  diff,
+  patch,
+  reverse,
+} from 'jsondiffpatch-rc';
+
+import tidyUpSequenceData from './tidyUpSequenceData';
+
+
+const getDiffFromSeqs = (oldData, newData, { ignoreKeys = [] } = {}) => {
+
+  oldData = tidyUpSequenceData(oldData, {
+    annotationsAsObjects: true,
+    noTranslationData: true,
+  });
+  newData = tidyUpSequenceData(newData, {
+    annotationsAsObjects: true,
+    noTranslationData: true,
+  });
+
+  [oldData, newData].forEach((d) => {
+    [
+      'cutsites',
+      'orfs',
+      'filteredFeatures',
+      'size',
+      'fromFileUpload',
+      'description',
+      'materiallyAvailable',
+      ...ignoreKeys,
+    ].forEach((prop) => {
+      delete d[prop];
+    });
+    if (d.translations) {
+      forEach(d.translations, (translation, key) => {
+        if (
+          translation.translationType &&
+          translation.translationType !== 'User Created'
+        ) {
+          delete d.translations[key];
+        } else {
+          delete translation.aminoAcids;
+        }
+      });
+    }
+  });
+
+  return diff(oldData, newData);
+};
+const patchSeqWithDiff = (oldData, diff, { ignoreKeys = [] } = {}) => {
+  ignoreKeys.forEach((k) => {
+    delete diff[k];
+  });
+  return patch(
+    tidyUpSequenceData(cloneDeep(oldData), { annotationsAsObjects: true }),
+    diff
+  );
+};
+const reverseSeqDiff = (diff) => {
+  return reverse(diff);
+};
+
+export { getDiffFromSeqs, patchSeqWithDiff, reverseSeqDiff };

package/src/diffUtils.test.js

@@ -0,0 +1,74 @@
+import chai from "chai";
+import assert from "assert";
+import {map} from "lodash";
+import tidyUpSequenceData from "./tidyUpSequenceData";
+import {getDiffFromSeqs, patchSeqWithDiff, reverseSeqDiff} from "./diffUtils";
+import chaiSubset from "chai-subset";
+
+chai.should();
+chai.use(chaiSubset);
+
+describe("getDiffFromSeqs patchSeqWithDiff reverseSeqDiff", () => {
+  it("ignores translation amino acids, cutsites, orfs, filteredFeatures, and works as expected", () => {
+    const originalSeq = tidyUpSequenceData(
+      {
+        sequence: "atagatagatagatagatagatagatagatagatagatagatagatagatagatag",
+        translations: [{ id: 10, start: 10, end: 24 }],
+        features: [],
+        cutsites: [{ name: "fakeSite" }],
+        orfs: [{ name: "fakeOrf", start: 10, end: 20 }],
+        filteredFeatures: [{ name: "filteredFeat1" }]
+      },
+      { annotationsAsObjects: true }
+    );
+
+    const alteredSeq = tidyUpSequenceData(
+      {
+        sequence: "agatagatagatagatagatagatagatagatagatagatagatagatagatag",
+        translations: [
+          { id: 10, start: 13, end: 24 },
+          { id: "awgwtwt", start: 3, end: 20, translationType: "CDS Feature" }
+        ],
+        cutsites: [{ name: "fakeSite" }],
+        orfs: [],
+        features: [{ name: "I'm new!", start: 30, end: 35 }],
+        filteredFeatures: [{ name: "filteredFeat1" }]
+      },
+      { annotationsAsObjects: true }
+    );
+
+    const diff = getDiffFromSeqs(originalSeq, alteredSeq);
+    assert(
+      !JSON.stringify(diff, null, 4).includes("aminoAcids"),
+      "Diffs should not include aminoAcids!"
+    );
+    assert(
+      !JSON.stringify(diff, null, 4).includes("cutsites"),
+      "Diffs should not include cutsites!"
+    );
+    assert(
+      !JSON.stringify(diff, null, 4).includes("translationType"),
+      "Diffs should not include non-user-created translations!"
+    );
+    //get the altered seq from the original by applying the diff between the two
+    const alteredSeqFromOriginalPatchedWithDiff = patchSeqWithDiff(
+      originalSeq,
+      diff
+    );
+    //the altered seq should have the expected features
+    map(alteredSeqFromOriginalPatchedWithDiff.features).should.containSubset([
+      {
+        name: "I'm new!",
+        start: 30,
+        end: 35
+      }
+    ]);
+    //get the original back from the altered by using the reversed diff
+    const originalSeqFromAlteredAndReversedDiff = patchSeqWithDiff(
+      alteredSeq,
+      reverseSeqDiff(diff)
+    );
+    //it should have no features!
+    map(originalSeqFromAlteredAndReversedDiff.features).length.should.equal(0);
+  });
+});

package/src/doesEnzymeChopOutsideOfRecognitionSite.js

@@ -0,0 +1,10 @@
+export default function doesEnzymeChopOutsideOfRecognitionSite(enzyme) {
+  if (
+    enzyme.topSnipOffset > enzyme.site.length ||
+    enzyme.bottomSnipOffset > enzyme.site.length
+  ) {
+    return true;
+  } else {
+    return false;
+  }
+};

package/src/doesEnzymeChopOutsideOfRecognitionSite.test.js

@@ -0,0 +1,41 @@
+
+
+import chai from "chai";
+import doesEnzymeChopOutsideOfRecognitionSite from "./doesEnzymeChopOutsideOfRecognitionSite.js";
+import enzymeList from "./aliasedEnzymesByName";
+
+chai.should();
+
+describe("doesEnzymeChopOutsideOfRecognitionSite", () => {
+  //bamhi
+  // "bamhi": {
+  //     "name": "bamhi",
+  //     "site": "ggatcdc",
+  //     "forwardRegex": "g{2}atc{2}",
+  //     "reverseRegex": "g{2}atc{2}",
+  //     "topSnipOffset": 1,
+  //     "bottomSnipOffset": 5
+  // },
+  // ATGATCAGA
+  // 012345678
+  it("should return a result for every enzyme", () => {
+    Object.keys(enzymeList).forEach(key => {
+      doesEnzymeChopOutsideOfRecognitionSite(enzymeList[key]);
+    });
+  });
+  it("knows which enzymes chop within the recognition site", () => {
+    doesEnzymeChopOutsideOfRecognitionSite(enzymeList["bamhi"]).should.equal(
+      false
+    );
+    doesEnzymeChopOutsideOfRecognitionSite(enzymeList["xhoi"]).should.equal(
+      false
+    );
+
+    doesEnzymeChopOutsideOfRecognitionSite(enzymeList["bsmbi"]).should.equal(
+      true
+    );
+    doesEnzymeChopOutsideOfRecognitionSite(enzymeList["bsai"]).should.equal(
+      true
+    );
+  });
+});

package/src/featureTypesAndColors.js

@@ -0,0 +1,152 @@
+import {get, keyBy, filter} from "lodash";
+
+const genbankFeatureTypes = [
+  { name: "-10_signal", color: "#4ECDC4" },
+  { name: "-35_signal", color: "#F7FFF7" },
+  { name: "3'clip", color: "#FF6B6B" },
+  { name: "3'UTR", color: "#FFE66D" },
+  { name: "5'clip", color: "#3E517A" },
+  { name: "5'UTR", color: "#BBBBBB" },
+  { name: "D-loop", color: "#F13C73" },
+  { name: "assembly_gap", color: "#DE9151" },
+  { name: "centromere", color: "#F34213" },
+  { name: "Het", color: "#BC5D2E" },
+  { name: "mobile_element", color: "#6DB1BF" },
+  { name: "ncRNA", color: "#FFEAEC" },
+  { name: "proprotein", color: "#F39A9D" },
+  { name: "regulatory", color: "#3F6C51" },
+  { name: "SecStr", color: "#7B4B94" },
+  { name: "Site", color: "#7D82B8" },
+  { name: "telomere", color: "DE9151" },
+  { name: "tmRNA", color: "#B7E3CC" },
+  { name: "unsure", color: "#C4FFB2" },
+  { name: "V_segment", color: "#D6F7A3" },
+  { name: "allele", color: "#D86D6D" },
+  { name: "attenuator", color: "#6B7F9C" },
+  { name: "C_region", color: "#B5D89D" },
+  { name: "CAAT_signal", color: "#E9CD98" },
+  { name: "CDS", color: "#EF6500" },
+  { name: "conserved", color: "#A3A5F0" },
+  { name: "D_segment", color: "#C060F7" },
+  { name: "default", color: "#CCCCCC" },
+  { name: "enhancer", color: "#38F872" },
+  { name: "exon", color: "#95F844" },
+  { name: "gap", color: "#F7D43C" },
+  { name: "GC_signal", color: "#861F1F" },
+  { name: "gene", color: "#684E27" },
+  { name: "iDNA", color: "#A59B41" },
+  { name: "intron", color: "#52963E" },
+  { name: "J_region", color: "#369283" },
+  { name: "LTR", color: "#31748F" },
+  { name: "m_rna", color: "#FFFF00" },
+  { name: "mat_peptide", color: "#353E8F" },
+  { name: "misc_binding", color: "#006FEF" },
+  { name: "misc_difference", color: "#5A368A" },
+  { name: "misc_feature", color: "#006FEF" },
+  { name: "misc_marker", color: "#8DCEB1" },
+  { name: "misc_part", color: "#006FEF" },
+  { name: "misc_recomb", color: "#DD97B4" },
+  { name: "misc_RNA", color: "#BD0101" },
+  { name: "misc_signal", color: "#FF9A04" },
+  { name: "misc_structure", color: "#B3FF00" },
+  { name: "modified_base", color: "#00F7FF" },
+  { name: "mRNA", color: "#FFD900" },
+  { name: "N_region", color: "#AE00FF" },
+  { name: "old_sequence", color: "#F0A7FF" },
+  { name: "operator", color: "#63004D" },
+  { name: "operon", color: "#000653" },
+  { name: "oriT", color: "#580000" },
+  { name: "plasmid", color: "#00635E" },
+  { name: "polyA_signal", color: "#BBBBBB" },
+  { name: "polyA_site", color: "#003328" },
+  { name: "precursor_RNA", color: "#443200" },
+  { name: "prim_transcript", color: "#665E4C" },
+  { name: "primer_bind", color: "#53d969" },
+  { name: "promoter", color: "#31B440" },
+  { name: "protein_bind", color: "#2E2E2E" },
+  { name: "protein_domain", color: "#4D4B4B" },
+  { name: "protein", color: "#696969" },
+  { name: "RBS", color: "#BDFFCB" },
+  { name: "rep_origin", color: "#878787" },
+  { name: "repeat_region", color: "#966363" },
+  { name: "repeat_unit", color: "#A16D8D" },
+  { name: "rRNA", color: "#9BF0FF" },
+  { name: "s_mutation", color: "#70A2FF" },
+  { name: "S_region", color: "#FF74A9" },
+  { name: "satellite", color: "#164E64" },
+  { name: "scRNA", color: "#A057FF" },
+  { name: "sig_peptide", color: "#2FFF8D" },
+  { name: "snoRNA", color: "#296B14" },
+  { name: "snRNA", color: "#A16249" },
+  { name: "source", color: "#0B17BD" },
+  { name: "start", color: "#D6A336" },
+  { name: "stem_loop", color: "#67069E" },
+  { name: "stop", color: "#D44FC9" },
+  { name: "STS", color: "#597FE7" },
+  { name: "tag", color: "#E419DA" },
+  { name: "TATA_signal", color: "#EB2B2B" },
+  { name: "terminator", color: "#F51600" },
+  { name: "transit_peptide", color: "#24D491" },
+  { name: "transposon", color: "#B6E436" },
+  { name: "tRNA", color: "#D1456F" },
+  { name: "V_region", color: "#7B5EE7" },
+  { name: "variation", color: "#2EE455" }
+];
+
+const getMergedFeatureMap = () => {
+  const keyedGBFeats = keyBy(
+    genbankFeatureTypes.map(f => ({
+      ...f,
+      isGenbankStandardType: true
+    })),
+    "name"
+  );
+  let featureOverrides =
+    (typeof window !== "undefined" && get(window, "tg_featureTypeOverrides")) ||
+    (typeof global !== "undefined" && get(global, "tg_featureTypeOverrides"));
+
+  featureOverrides = featureOverrides || [];
+  featureOverrides = featureOverrides.map(fo => {
+    const originalGenbankFeat = keyedGBFeats[fo.name];
+    return {
+      ...originalGenbankFeat,
+      ...fo,
+      ...(originalGenbankFeat ? { isOverridden: true } : { isCustomType: true })
+    };
+  });
+  featureOverrides = keyBy(featureOverrides, "name");
+
+  return {
+    ...keyedGBFeats,
+    ...featureOverrides
+  };
+};
+
+const getFeatureToColorMap = ({ includeHidden } = {}) => {
+  const toRet = {};
+  filter(getMergedFeatureMap(), f =>
+    includeHidden ? true : !f.isHidden
+  ).forEach(f => {
+    toRet[f.name] = f.color;
+  });
+  return toRet;
+};
+
+const getFeatureTypes = ({ includeHidden } = {}) =>
+  filter(getMergedFeatureMap(), f => (includeHidden ? true : !f.isHidden)).map(
+    f => f.name
+  );
+
+export {genbankFeatureTypes};
+
+export function getGenbankFeatureToColorMap() {
+  const toRet = {};
+  genbankFeatureTypes.forEach(({ name, color }) => {
+    toRet[name] = color;
+  });
+  return toRet;
+}
+
+export {getFeatureToColorMap};
+export {getFeatureTypes};
+export {getMergedFeatureMap};

package/src/featureTypesAndColors.test.js

@@ -0,0 +1,52 @@
+import {
+  getFeatureTypes,
+  getFeatureToColorMap,
+  getMergedFeatureMap,
+  getGenbankFeatureToColorMap,
+} from "./featureTypesAndColors";
+
+describe("getFeatureToColorMap", () => {
+  it("should pass back feature colors by default ", () => {
+    expect(getFeatureToColorMap().proprotein).toEqual("#F39A9D");
+  });
+  it("getFeatureTypes should not show hidden types by default ", () => {
+    global.tg_featureTypeOverrides = [
+      { name: "proprotein", isHidden: true },
+      { name: "CDS", color: "blue" },
+      { name: "someRandomFeature", color: "red", genbankEquivalentType: "RBS" }
+    ];
+    expect(getFeatureTypes().includes("proprotein")).toEqual(false);
+    expect(getFeatureTypes().includes("CDS")).toEqual(true);
+    expect(
+      getFeatureTypes({ includeHidden: true }).includes("proprotein")
+    ).toEqual(true);
+  });
+
+  it("should allow overwriting of colors ", () => {
+    global.tg_featureTypeOverrides = [
+      { name: "proprotein", isHidden: true },
+      { name: "CDS", color: "blue" },
+      { name: "someRandomFeature", color: "red", genbankEquivalentType: "RBS" }
+    ];
+    const featMap = getFeatureToColorMap();
+    expect(featMap.CDS).toEqual("blue");
+    // expect(featMap.CDS.isGenbankStandardType).toEqual(true);
+    expect(featMap.proprotein).toEqual(undefined);
+    expect(featMap.someRandomFeature).toEqual("red");
+    expect(getGenbankFeatureToColorMap().someRandomFeature).toEqual(undefined);
+  });
+});
+describe("getMergedFeatureMap", () => {
+  it("should maintain the genbankEquivalentType", () => {
+    global.tg_featureTypeOverrides = [
+      { name: "proprotein", isHidden: true },
+      { name: "CDS", color: "blue" },
+      { name: "someRandomFeature", color: "red", genbankEquivalentType: "RBS" }
+    ];
+    const mergedFeatMap = getMergedFeatureMap();
+    expect(mergedFeatMap.someRandomFeature.genbankEquivalentType).toEqual(
+      "RBS"
+    );
+    expect(mergedFeatMap.CDS.isGenbankStandardType).toEqual(true);
+  });
+});

package/src/filterAminoAcidSequenceString.js

@@ -0,0 +1,13 @@
+//
+export default function filterAminoAcidSequenceString(
+  sequenceString,
+  options
+) {
+  options = options || {};
+  if (options.includeStopCodon) {
+    //tnrtodo this maybe needs the stop codon char in it?
+    return sequenceString.replace(/[^xtgalmfwkqespvicyhrndu.*]/gi, "");
+  }
+  // ac.throw(ac.string, sequenceString);
+  return sequenceString.replace(/[^xtgalmfwkqespvicyhrndu]/gi, "");
+};

package/src/filterAminoAcidSequenceString.test.js

@@ -0,0 +1,22 @@
+import assert from "assert";
+import filterAminoAcidSequenceString from "./filterAminoAcidSequenceString";
+describe("filterAminoAcidSequenceString", () => {
+  it("should filter only valid amino acids by default", () => {
+    const filteredString = filterAminoAcidSequenceString(
+      'bbb342"""xtgalmfwkqespvicyhrnd,,../'
+    );
+    assert.equal(filteredString, "xtgalmfwkqespvicyhrnd");
+  });
+  it("should handle upper case letters", () => {
+    const filteredString = filterAminoAcidSequenceString("xtgalmfWKQEspvicyhrnd");
+    assert.equal(filteredString, "xtgalmfWKQEspvicyhrnd");
+  });
+  it("should handle the option to includeStopCodon by allowing periods", () => {
+    const options = { includeStopCodon: true };
+    const filteredString = filterAminoAcidSequenceString(
+      'bbb342"""xtgalmfwkqespvicyhrnd,,../',
+      options
+    );
+    assert.equal(filteredString, "xtgalmfwkqespvicyhrnd..");
+  });
+});

package/src/filterSequenceString.js

@@ -0,0 +1,22 @@
+// this is throwing a weird eslint error
+
+//
+export default function filterSequenceString(
+  sequenceString,
+  additionalValidChars = "",
+  charOverrides
+) {
+  // ac.throw(ac.string,sequenceString);
+  if (sequenceString) {
+    return sequenceString.replace(
+      new RegExp(
+        `[^${charOverrides ||
+          `atgcyrswkmbvdhnu${additionalValidChars.split("").join("\\")}`}]`,
+        "gi"
+      ),
+      ""
+    );
+  } else {
+    return sequenceString;
+  }
+};

package/src/filterSequenceString.test.js

@@ -0,0 +1,13 @@
+import filterSequenceString from "./filterSequenceString";
+
+describe("filterSequenceString", () => {
+  it("should filter out unwanted chars", () => {
+    expect(filterSequenceString("tatag--a")).toBe("tataga");
+  });
+  it("should handle additional chars option", () => {
+    expect(filterSequenceString("tatag--a", "-")).toBe("tatag--a");
+  });
+  it("should handle additional chars option", () => {
+    expect(filterSequenceString("tatag--a", "f-q")).toBe("tatag--a");
+  });
+});

package/src/findNearestRangeOfSequenceOverlapToPosition.js

@@ -0,0 +1,39 @@
+import {normalizeRange} from "@teselagen/range-utils";
+function findNearestRangeOfSequenceOverlapToPosition(
+  sequenceToSearch,
+  overlapSequence,
+  positionStart,
+  isLinear
+) {
+  if (!positionStart) positionStart = 0;
+  if (sequenceToSearch.length < overlapSequence.length) {
+    return null;
+  }
+  const regex = new RegExp(overlapSequence, "ig");
+  let result;
+  let index;
+  let distance = Infinity;
+  while (
+    (result = regex.exec(sequenceToSearch + (isLinear ? "" : sequenceToSearch)))
+  ) {
+    if (result.index > sequenceToSearch.length) break;
+    let newDistance = Math.abs(result.index - positionStart);
+    newDistance = isLinear
+      ? newDistance //if linear, don't check around the origin
+      : Math.min(newDistance, Math.abs(newDistance - sequenceToSearch.length));
+    if (newDistance > distance) {
+      break;
+    }
+    index = result.index;
+    distance = newDistance;
+  }
+  //index is the closest range start
+  return normalizeRange(
+    {
+      start: index,
+      end: index + overlapSequence.length - 1
+    },
+    sequenceToSearch.length
+  );
+}
+export default findNearestRangeOfSequenceOverlapToPosition;