@teselagen/sequence-utils 0.1.22 → 0.1.23

package/src/guessIfSequenceIsDnaAndNotProtein.js

@@ -0,0 +1,33 @@
+import {ambiguous_dna_letters} from "./bioData";
+
+export default function guessIfSequenceIsDnaAndNotProtein(seq, options = {}) {
+  const { threshold = 0.9, loose } = options;
+  const dnaLetters =
+    options.dnaLetters || loose
+      ? [...ambiguous_dna_letters.split(""), "U"]
+      : ["G", "A", "T", "C", "U"];
+  // Guess if the given sequence is DNA or Protein.
+
+  //   It's considered DNA if more than 90% of the sequence is GATCs. The threshold
+  //   is configurable via the threshold parameter. dnaLetters can be used to configure
+  //   which letters are considered DNA; for instance, adding N might be useful if
+  //   you are expecting data with ambiguous bases.
+  const dnaLetterMap = dnaLetters.reduce((acc, letter) => {
+    acc[letter.toUpperCase()] = true;
+    return acc;
+  }, {});
+  let count = 0;
+  if (!seq || !seq.length) return true;
+
+  for (let index = 0; index < seq.length; index++) {
+    const letter = seq[index];
+    if (dnaLetterMap[letter.toUpperCase()]) {
+      count = count + 1;
+    }
+  }
+
+  if (count / seq.length > threshold) {
+    return true; //it is DNA
+  }
+  return false; //it is protein
+};

package/src/guessIfSequenceIsDnaAndNotProtein.test.js

@@ -0,0 +1,34 @@
+import chai from "chai";
+import guessIfSequenceIsDnaAndNotProtein from "./guessIfSequenceIsDnaAndNotProtein";
+chai.should();
+describe("guessIfSequenceIsDnaAndNotProtein", () => {
+  it("should default to DNA for a length 0 sequecne", () => {
+    guessIfSequenceIsDnaAndNotProtein("").should.equal(true);
+  });
+  it("should correctly guess that a DNA seq is DNA", () => {
+    guessIfSequenceIsDnaAndNotProtein("gtatacc").should.equal(true);
+  });
+  it("should correctly guess that a DNA seq with some ambiguity is a DNA", () => {
+    guessIfSequenceIsDnaAndNotProtein("gtatacctaacn").should.equal(true);
+  });
+  it("should correctly guess that a seq with lots of ambiguity is a protein when in the default strict mode", () => {
+    guessIfSequenceIsDnaAndNotProtein("gtatacybctaacn", {
+      loose: false
+    }).should.equal(false);
+  });
+  it("should correctly guess that a seq with lots of ambiguity is dna when in the loose mode", () => {
+    guessIfSequenceIsDnaAndNotProtein("gtatacybctaacn", {
+      loose: true
+    }).should.equal(true);
+  });
+  it("should correctly guess that a DNA with lots of ambiguities is dna when the threshold is lower  ", () => {
+    guessIfSequenceIsDnaAndNotProtein("gtatacybctaacn", {
+      threshold: 0.5
+    }).should.equal(true);
+  });
+  it("should correctly guess that a DNA with lots of ambiguity is a dna when the ambiguous letter is included ", () => {
+    guessIfSequenceIsDnaAndNotProtein("gtatanccnnntaacn", {
+      dnaLetters: ["g", "a", "t", "c", "n"]
+    }).should.equal(true);
+  });
+});

package/src/index.js

@@ -0,0 +1,106 @@
+import {
+  autoAnnotate,
+  convertApELikeRegexToRegex,
+  convertProteinSeqToDNAIupac,
+} from './autoAnnotate';
+
+import {
+  genbankFeatureTypes,
+  getFeatureToColorMap,
+  getFeatureTypes,
+  getMergedFeatureMap,
+} from './featureTypesAndColors';
+
+export * from './computeDigestFragments';
+export * from './diffUtils';
+export * from './annotationTypes';
+
+/* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ */
+//tnr: these are deprecated exports and should no longer be used!
+const FeatureTypes = getFeatureTypes();
+const featureColors = getFeatureToColorMap();
+export {
+  getFeatureToColorMap,
+  getFeatureTypes,
+  genbankFeatureTypes,
+  getMergedFeatureMap,
+  FeatureTypes,
+  featureColors,
+};
+
+/* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ */
+export { autoAnnotate };
+export { convertApELikeRegexToRegex };
+export { convertProteinSeqToDNAIupac };
+export * as bioData from './bioData';
+export { default as getAllInsertionsInSeqReads } from './getAllInsertionsInSeqReads';
+export { default as annotateSingleSeq } from './annotateSingleSeq';
+export { default as getDegenerateDnaStringFromAAString } from './getDegenerateDnaStringFromAAString';
+export { default as getDegenerateRnaStringFromAAString } from './getDegenerateRnaStringFromAAString';
+export { default as getVirtualDigest } from './getVirtualDigest';
+export { default as isEnzymeType2S } from './isEnzymeType2S';
+export { default as insertGapsIntoRefSeq } from './insertGapsIntoRefSeq';
+export { default as adjustBpsToReplaceOrInsert } from './adjustBpsToReplaceOrInsert';
+export { default as calculatePercentGC } from './calculatePercentGC';
+export { default as calculateTm } from './calculateTm';
+export { default as cutSequenceByRestrictionEnzyme } from './cutSequenceByRestrictionEnzyme';
+export { default as deleteSequenceDataAtRange } from './deleteSequenceDataAtRange';
+export { default as DNAComplementMap } from './DNAComplementMap';
+export { default as doesEnzymeChopOutsideOfRecognitionSite } from './doesEnzymeChopOutsideOfRecognitionSite';
+export { default as aliasedEnzymesByName } from './aliasedEnzymesByName';
+export { default as defaultEnzymesByName } from './defaultEnzymesByName';
+export { default as generateSequenceData } from './generateSequenceData';
+export { default as generateAnnotations } from './generateAnnotations';
+export { default as filterAminoAcidSequenceString } from './filterAminoAcidSequenceString';
+export { default as filterSequenceString } from './filterSequenceString';
+export { default as findNearestRangeOfSequenceOverlapToPosition } from './findNearestRangeOfSequenceOverlapToPosition';
+export { default as findOrfsInPlasmid } from './findOrfsInPlasmid';
+export { default as findSequenceMatches } from './findSequenceMatches';
+export { default as getAminoAcidDataForEachBaseOfDna } from './getAminoAcidDataForEachBaseOfDna';
+export { default as getAminoAcidFromSequenceTriplet } from './getAminoAcidFromSequenceTriplet';
+export { default as getAminoAcidStringFromSequenceString } from './getAminoAcidStringFromSequenceString';
+export { default as getCodonRangeForAASliver } from './getCodonRangeForAASliver';
+export { default as getComplementAminoAcidStringFromSequenceString } from './getComplementAminoAcidStringFromSequenceString';
+export { default as getComplementSequenceAndAnnotations } from './getComplementSequenceAndAnnotations';
+export { default as getComplementSequenceString } from './getComplementSequenceString';
+export { default as getCutsitesFromSequence } from './getCutsitesFromSequence';
+export { default as getCutsiteType } from './getCutsiteType';
+export { default as getInsertBetweenVals } from './getInsertBetweenVals';
+export { default as getLeftAndRightOfSequenceInRangeGivenPosition } from './getLeftAndRightOfSequenceInRangeGivenPosition';
+export { default as getOrfsFromSequence } from './getOrfsFromSequence';
+export { default as getOverlapBetweenTwoSequences } from './getOverlapBetweenTwoSequences';
+export { default as getPossiblePartsFromSequenceAndEnzymes } from './getPossiblePartsFromSequenceAndEnzymes';
+export { default as getReverseAminoAcidStringFromSequenceString } from './getReverseAminoAcidStringFromSequenceString';
+export { default as getReverseComplementAminoAcidStringFromSequenceString } from './getReverseComplementAminoAcidStringFromSequenceString';
+export { default as getReverseComplementAnnotation } from './getReverseComplementAnnotation';
+export { default as getReverseComplementSequenceAndAnnotations } from './getReverseComplementSequenceAndAnnotations';
+export { default as getReverseComplementSequenceString } from './getReverseComplementSequenceString';
+export { default as getReverseSequenceString } from './getReverseSequenceString';
+export { default as getSequenceDataBetweenRange } from './getSequenceDataBetweenRange';
+export { default as guessIfSequenceIsDnaAndNotProtein } from './guessIfSequenceIsDnaAndNotProtein';
+export { default as insertSequenceDataAtPosition } from './insertSequenceDataAtPosition';
+export { default as insertSequenceDataAtPositionOrRange } from './insertSequenceDataAtPositionOrRange';
+export { default as mapAnnotationsToRows } from './mapAnnotationsToRows';
+export { default as prepareCircularViewData } from './prepareCircularViewData';
+export { default as prepareRowData } from './prepareRowData';
+export { default as proteinAlphabet } from './proteinAlphabet';
+export { default as rotateSequenceDataToPosition } from './rotateSequenceDataToPosition';
+export { default as rotateBpsToPosition } from './rotateBpsToPosition';
+export { default as threeLetterSequenceStringToAminoAcidMap } from './threeLetterSequenceStringToAminoAcidMap';
+export { default as tidyUpSequenceData } from './tidyUpSequenceData';
+export { default as tidyUpAnnotation } from './tidyUpAnnotation';
+export { default as condensePairwiseAlignmentDifferences } from './condensePairwiseAlignmentDifferences';
+export { default as addGapsToSeqReads } from './addGapsToSeqReads';
+export { default as calculateNebTm } from './calculateNebTm';
+export { default as calculateNebTa } from './calculateNebTa';
+export { default as getDigestFragmentsForCutsites } from './getDigestFragmentsForCutsites';
+export { default as getDigestFragmentsForRestrictionEnzymes } from './getDigestFragmentsForRestrictionEnzymes';
+export { default as convertDnaCaretPositionOrRangeToAA } from './convertDnaCaretPositionOrRangeToAA';
+export { default as convertAACaretPositionOrRangeToDna } from './convertAACaretPositionOrRangeToDna';
+export { default as aminoAcidToDegenerateDnaMap } from './aminoAcidToDegenerateDnaMap';
+export { default as aminoAcidToDegenerateRnaMap } from './aminoAcidToDegenerateRnaMap';
+export { default as degenerateDnaToAminoAcidMap } from './degenerateDnaToAminoAcidMap';
+export { default as degenerateRnaToAminoAcidMap } from './degenerateRnaToAminoAcidMap';
+export { default as getMassOfAaString } from './getMassOfAaString';
+export { default as shiftAnnotationsByLen } from './shiftAnnotationsByLen';
+export { default as adjustAnnotationsToInsert } from './adjustAnnotationsToInsert';

package/src/index.test.js

@@ -0,0 +1,38 @@
+import * as src from ".";
+import fs from "fs";
+
+describe("index.js", () => {
+  it(`should export all functions defined`, () => {
+    return new Promise((resolve) => {
+
+      fs.readdir(__dirname, (err, files) => {
+        let passes = true;
+        files.forEach(file => {
+          if (
+            file.indexOf(".test.js") > -1 ||
+            file.indexOf("index.js") > -1 ||
+            file.indexOf("prepareRowData_output1.json") > -1 ||
+            file.indexOf("featureTypesAndColors") > -1 ||
+            file.indexOf("diffUtils") > -1 ||
+            file.indexOf(".test.js") > -1 ||
+            file.indexOf("index.js") > -1
+          ) {
+            return;
+          }
+          const funcOrObj = src[file.replace(".js", "")];
+          if (!funcOrObj) {
+            console.info(
+              `Uh oh, it looks like you forgot to export (or explicitly ignore) this file:`,
+              file
+            );
+            passes = false;
+          }
+        });
+        if (!passes) {
+          throw new Error("Please make sure to export (or ignore) each file! Update index.js to export the file");
+        }
+        resolve();
+      });
+    })
+  });
+});

package/src/insertGapsIntoRefSeq.js

@@ -0,0 +1,38 @@
+import getAllInsertionsInSeqReads from "./getAllInsertionsInSeqReads.js";
+
+// seqReads should be an array of objects [{name, seq, pos, cigar}, {name, seq, pos, cigar}, ...]
+// add gaps in reference sequence where there are insertions
+export default function insertGapsIntoRefSeq(refSeq, seqReads) {
+  // turn ref seq into an array ["A", "T", "C", "G"...]
+  const refSeqWithGaps = refSeq.split("");
+  const allInsertionsInSeqReads = getAllInsertionsInSeqReads(seqReads);
+  for (let i = 0; i < allInsertionsInSeqReads.length; i++) {
+    const bpPosOfInsertion = allInsertionsInSeqReads[i].bpPos;
+    const numberOfInsertions = allInsertionsInSeqReads[i].number;
+    // adding gaps at the bp pos of insertion
+    let insertionGaps = "";
+    for (let gapI = 0; gapI < numberOfInsertions; gapI++) {
+      insertionGaps += "-";
+    }
+    refSeqWithGaps.splice(bpPosOfInsertion - 1, 0, insertionGaps);
+    for (let posI = i + 1; posI < allInsertionsInSeqReads.length; posI++) {
+      allInsertionsInSeqReads[posI].bpPos += 1;
+    }
+  }
+  // refSeqWithGaps is a string "GGGA--GA-C--ACC"
+  return refSeqWithGaps.join("");
+};
+
+// allInsertionsInSeqReads.forEach(insertion => {
+//       // adding gap at the bp pos of insertion
+//       refSeqWithGaps.splice(insertion - 1, 0, "-");
+//   });
+//   for (let i = 0; i < allInsertionsInSeqReads.length; i++) {
+//     refSeqWithGaps.splice(allInsertionsInSeqReads[i] - 1, 0, "-");
+//     for (let innerI = i + 1; innerI < allInsertionsInSeqReads.length; innerI++){
+//       if (refSeqWithGaps[i] - 1 !== "-") {
+//         // allInsertionsInSeqReads[innerI] += 1;
+//         allInsertionsInSeqReads[i + 1] += 1;
+//       }
+//     }
+//   }

package/src/insertGapsIntoRefSeq.test.js

@@ -0,0 +1,20 @@
+import insertGapsIntoRefSeq from "./insertGapsIntoRefSeq.js";
+
+describe("insert gaps into ref seq from seq reads' insertions", () => {
+  it("ref seq with all insertions", () => {
+    const refSeq = "GGGAGACACC";
+    const seqReads = [
+      { name: "r1", seq: "GATTGAC", pos: 3, cigar: "2M2I3M" },
+      { name: "r2", seq: "GAGAGAC", pos: 3, cigar: "7M" },
+      { name: "r3", seq: "GGGAGATCAC", pos: 1, cigar: "6M1I3M" },
+      { name: "r4", seq: "GATTGAC", pos: 3, cigar: "2M2I3M" },
+      { name: "r5", seq: "GAGC", pos: 3, cigar: "3M1D1M" },
+      { name: "r6", seq: "GAGCTTACC", pos: 3, cigar: "3M1D1M2I3M" },
+      { name: "r7", seq: "GGCATTTCC", pos: 2, cigar: "2M3D2M3I2M" },
+      { name: "r8", seq: "GGATTGACATT", pos: 1, cigar: "1D3M2I4M2I2D" },
+      { name: "r9", seq: "GGTTTGACCTTT", pos: 1, cigar: "2M3I2D1M2D3M3I" }
+    ];
+    const result = insertGapsIntoRefSeq(refSeq, seqReads);
+    expect(result).toEqual("GG---GA--GA-C--A---CC---");
+  });
+});

package/src/insertSequenceDataAtPosition.js

@@ -0,0 +1,2 @@
+import insertSequenceDataAtPositionOrRange from "./insertSequenceDataAtPositionOrRange";
+export default insertSequenceDataAtPositionOrRange;

package/src/insertSequenceDataAtPosition.test.js

@@ -0,0 +1,75 @@
+//tnr: half finished test.
+
+
+import chai from "chai";
+import chaiSubset from "chai-subset";
+
+import tidyUpSequenceData from "./tidyUpSequenceData";
+import insertSequenceDataAtPosition from "./insertSequenceDataAtPosition";
+
+chai.should();
+chai.use(chaiSubset);
+
+describe("insertSequenceData", () => {
+  it("inserts characters at correct caret position", () => {
+    let seqToInsert = {
+      sequence: "atgagagaga"
+    };
+    let preInsertSeq = {
+      sequence: "0"
+    };
+    seqToInsert = tidyUpSequenceData(seqToInsert);
+    const caretPosition = 0;
+    preInsertSeq = tidyUpSequenceData({});
+    const postInsertSeq = insertSequenceDataAtPosition(
+      seqToInsert,
+      preInsertSeq,
+      caretPosition
+    );
+    postInsertSeq.sequence.length.should.equal(
+      preInsertSeq.sequence.length + seqToInsert.sequence.length
+    );
+  });
+  it("inserts characters at correct caret position", () => {
+    let seqToInsert = {
+      sequence: "atgagagaga"
+    };
+    let preInsertSeq = {
+      sequence: "atgagagaga",
+      features: [
+        {
+          start: 0,
+          end: 9,
+          locations: [{ start: 0, end: 3 }, { start: 5, end: 9 }]
+        }
+      ]
+    };
+    seqToInsert = tidyUpSequenceData(seqToInsert);
+    preInsertSeq = tidyUpSequenceData(preInsertSeq);
+    const caretPosition = 0;
+    const postInsertSeq = insertSequenceDataAtPosition(
+      seqToInsert,
+      preInsertSeq,
+      caretPosition
+    );
+    postInsertSeq.sequence.length.should.equal(
+      preInsertSeq.sequence.length + seqToInsert.sequence.length
+    );
+    postInsertSeq.features.length.should.equal(1);
+    postInsertSeq.features[0].start.should.equal(
+      preInsertSeq.features[0].start + seqToInsert.sequence.length
+    );
+    postInsertSeq.features[0].locations[0].start.should.equal(
+      preInsertSeq.features[0].locations[0].start + seqToInsert.sequence.length
+    );
+    postInsertSeq.features[0].locations[1].start.should.equal(
+      preInsertSeq.features[0].locations[1].start + seqToInsert.sequence.length
+    );
+    postInsertSeq.features[0].locations[0].end.should.equal(
+      preInsertSeq.features[0].locations[0].end + seqToInsert.sequence.length
+    );
+    postInsertSeq.features[0].locations[1].end.should.equal(
+      preInsertSeq.features[0].locations[1].end + seqToInsert.sequence.length
+    );
+  });
+});

package/src/insertSequenceDataAtPositionOrRange.js

@@ -0,0 +1,249 @@
+import {getRangeLength} from "@teselagen/range-utils";
+import {map, cloneDeep} from "lodash";
+import convertDnaCaretPositionOrRangeToAa from "./convertDnaCaretPositionOrRangeToAA";
+import rotateSequenceDataToPosition from "./rotateSequenceDataToPosition";
+import {adjustRangeToDeletionOfAnotherRange} from "@teselagen/range-utils";
+import tidyUpSequenceData from "./tidyUpSequenceData";
+import {modifiableTypes} from "./annotationTypes";
+import adjustBpsToReplaceOrInsert from "./adjustBpsToReplaceOrInsert";
+import adjustAnnotationsToInsert from "./adjustAnnotationsToInsert";
+
+export default function insertSequenceDataAtPositionOrRange(
+  _sequenceDataToInsert,
+  _existingSequenceData,
+  caretPositionOrRange,
+  options = {}
+) {
+  //maintainOriginSplit means that if you're inserting around the origin with n bps selected before the origin
+  //when inserting new seq, n bps of the new seq should go in before the origin and the rest should be
+  //inserted at the sequence start
+  const { maintainOriginSplit } = options;
+  let existingSequenceData = tidyUpSequenceData(_existingSequenceData, options);
+  const sequenceDataToInsert = tidyUpSequenceData(
+    _sequenceDataToInsert,
+    options
+  );
+  const newSequenceData = cloneDeep(existingSequenceData);
+  const insertLength = sequenceDataToInsert.proteinSequence
+    ? sequenceDataToInsert.proteinSequence.length * 3
+    : sequenceDataToInsert.sequence.length;
+  let caretPosition = caretPositionOrRange;
+
+  const isInsertSameLengthAsSelection =
+    sequenceDataToInsert.sequence.length ===
+    getRangeLength(caretPositionOrRange, existingSequenceData.sequence.length);
+
+  if (
+    caretPositionOrRange.start > -1 &&
+    getRangeLength(
+      caretPositionOrRange,
+      existingSequenceData.sequence.length
+    ) === existingSequenceData.sequence.length
+  ) {
+    //handle the case where we're deleting everything!
+    existingSequenceData = tidyUpSequenceData(
+      {
+        ...existingSequenceData,
+        ...modifiableTypes.reduce((acc, type) => {
+          return (acc[type] = []);
+        }, {}),
+        sequence: "",
+        proteinSequence: "",
+        chromatogramData: undefined
+      },
+      options
+    );
+    newSequenceData.chromatogramData = undefined;
+  } else if (
+    newSequenceData.chromatogramData &&
+    newSequenceData.chromatogramData.baseTraces
+  ) {
+    //handle chromatogramData updates
+    if (caretPositionOrRange && caretPositionOrRange.start > -1) {
+      if (caretPositionOrRange.start > caretPositionOrRange.end) {
+        newSequenceData.chromatogramData = trimChromatogram({
+          chromatogramData: newSequenceData.chromatogramData,
+          range: {
+            start: caretPositionOrRange.start,
+            end: newSequenceData.sequence.length
+          },
+          justBaseCalls: isInsertSameLengthAsSelection
+        });
+        newSequenceData.chromatogramData = trimChromatogram({
+          chromatogramData: newSequenceData.chromatogramData,
+          range: {
+            start: 0,
+            end: caretPositionOrRange.end
+          },
+          justBaseCalls: isInsertSameLengthAsSelection
+        });
+      } else {
+        newSequenceData.chromatogramData = trimChromatogram({
+          chromatogramData: newSequenceData.chromatogramData,
+          range: {
+            start: caretPositionOrRange.start,
+            end: caretPositionOrRange.end
+          },
+          justBaseCalls: isInsertSameLengthAsSelection
+        });
+      }
+    }
+    if (sequenceDataToInsert.sequence) {
+      insertIntoChromatogram({
+        chromatogramData: newSequenceData.chromatogramData,
+        caretPosition:
+          caretPositionOrRange.start > -1
+            ? caretPositionOrRange.start
+            : caretPositionOrRange,
+        seqToInsert: sequenceDataToInsert.sequence,
+        justBaseCalls: isInsertSameLengthAsSelection
+      });
+    }
+  }
+
+  //update the sequence
+  newSequenceData.sequence = adjustBpsToReplaceOrInsert(
+    existingSequenceData.sequence,
+    sequenceDataToInsert.sequence,
+    caretPositionOrRange
+  );
+  newSequenceData.size = newSequenceData.sequence.length;
+  newSequenceData.proteinSequence = adjustBpsToReplaceOrInsert(
+    existingSequenceData.proteinSequence,
+    sequenceDataToInsert.proteinSequence,
+    convertDnaCaretPositionOrRangeToAa(caretPositionOrRange)
+  );
+  newSequenceData.proteinSize = newSequenceData.proteinSequence.length;
+
+  //handle the insert
+  modifiableTypes.forEach(annotationType => {
+    let existingAnnotations = existingSequenceData[annotationType];
+    //update the annotations:
+    //handle the delete if necessary
+    if (caretPositionOrRange && caretPositionOrRange.start > -1) {
+      //we have a range! so let's delete it!
+      const range = caretPositionOrRange;
+      caretPosition = range.start > range.end ? 0 : range.start;
+      //update all annotations for the deletion
+      existingAnnotations = adjustAnnotationsToDelete(
+        existingAnnotations,
+        range,
+        existingSequenceData.sequence.length
+      );
+    }
+    //first clear the newSequenceData's annotations
+    newSequenceData[annotationType] = [];
+    //in two steps adjust the annotations to the insert
+    newSequenceData[annotationType] = newSequenceData[annotationType].concat(
+      adjustAnnotationsToInsert(
+        existingAnnotations,
+        caretPosition,
+        insertLength
+      )
+    );
+    newSequenceData[annotationType] = newSequenceData[annotationType].concat(
+      adjustAnnotationsToInsert(
+        sequenceDataToInsert[annotationType],
+        0,
+        caretPosition
+      )
+    );
+  });
+  if (
+    maintainOriginSplit &&
+    caretPositionOrRange &&
+    caretPositionOrRange.start > caretPositionOrRange.end
+  ) {
+    //we're replacing around the origin and maintainOriginSplit=true
+    //so rotate the resulting seqData n bps
+    const caretPosToRotateTo =
+      existingSequenceData.sequence.length - caretPositionOrRange.start;
+    return rotateSequenceDataToPosition(
+      newSequenceData,
+      Math.min(caretPosToRotateTo, insertLength)
+    );
+  }
+  return newSequenceData;
+};
+
+function adjustAnnotationsToDelete(annotationsToBeAdjusted, range, maxLength) {
+  return map(annotationsToBeAdjusted, annotation => {
+    const newRange = adjustRangeToDeletionOfAnotherRange(
+      annotation,
+      range,
+      maxLength
+    );
+    const newLocations =
+      annotation.locations &&
+      annotation.locations
+        .map(loc => adjustRangeToDeletionOfAnotherRange(loc, range, maxLength))
+        .filter(range => !!range);
+    if (newLocations && newLocations.length) {
+      return {
+        ...newRange,
+        start: newLocations[0].start,
+        end: newLocations[newLocations.length - 1].end,
+        ...(newLocations.length > 1 && { locations: newLocations })
+      };
+    } else {
+      return newRange;
+    }
+  }).filter(range => !!range); //filter any fully deleted ranges
+}
+
+function insertIntoChromatogram({
+  chromatogramData,
+  caretPosition,
+  seqToInsert,
+  justBaseCalls
+}) {
+  if (!seqToInsert.length) return;
+
+  chromatogramData.baseCalls &&
+    chromatogramData.baseCalls.splice(
+      caretPosition,
+      0,
+      ...seqToInsert.split("")
+    );
+  if (justBaseCalls) {
+    //return early if just base calls
+    return chromatogramData;
+  }
+
+  const baseTracesToInsert = [];
+  const qualNumsToInsert = [];
+
+  for (let index = 0; index < seqToInsert.length; index++) {
+    qualNumsToInsert.push(0);
+    const toPush = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    baseTracesToInsert.push({
+      aTrace: toPush,
+      cTrace: toPush,
+      gTrace: toPush,
+      tTrace: toPush
+    });
+  }
+
+  chromatogramData.baseTraces &&
+    chromatogramData.baseTraces.splice(caretPosition, 0, ...baseTracesToInsert);
+  chromatogramData.qualNums &&
+    chromatogramData.qualNums.splice(caretPosition, 0, ...qualNumsToInsert);
+
+  return chromatogramData;
+}
+
+function trimChromatogram({
+  chromatogramData,
+  range: { start, end },
+  justBaseCalls
+}) {
+  [
+    "baseCalls",
+    ...(justBaseCalls ? [] : ["qualNums", "baseTraces", "basePos"])
+  ].forEach(type => {
+    chromatogramData[type] &&
+      chromatogramData[type].splice(start, end - start + 1);
+  });
+
+  return chromatogramData;
+}