@teselagen/sequence-utils 0.3.41 → 0.3.42-beta.2

package/src/diffUtils.js

@@ -1,63 +0,0 @@
-import { cloneDeep, forEach } from "lodash-es";
-import { diff, patch, reverse } from "jsondiffpatch";
-
-import tidyUpSequenceData from "./tidyUpSequenceData";
-
-const getDiffFromSeqs = (oldData, newData, { ignoreKeys = [] } = {}) => {
-  oldData = tidyUpSequenceData(oldData, {
-    annotationsAsObjects: true,
-    noTranslationData: true,
-    doNotRemoveInvalidChars: true
-  });
-  newData = tidyUpSequenceData(newData, {
-    annotationsAsObjects: true,
-    noTranslationData: true,
-    doNotRemoveInvalidChars: 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,
-      doNotRemoveInvalidChars: true
-    }),
-    diff
-  );
-};
-const reverseSeqDiff = diff => {
-  return reverse(diff);
-};
-
-export { getDiffFromSeqs, patchSeqWithDiff, reverseSeqDiff };

package/src/doesEnzymeChopOutsideOfRecognitionSite.js

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

package/src/getCutsiteType.js

@@ -1,10 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

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

package/src/getDegenerateRnaStringFromAAString.js

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

package/src/getDigestFragmentsForRestrictionEnzymes.js

@@ -1,27 +0,0 @@
-import getDigestFragmentsForCutsites from "./getDigestFragmentsForCutsites";
-import cutSequenceByRestrictionEnzyme from "./cutSequenceByRestrictionEnzyme";
-import { flatMap } from "lodash-es";
-
-export default function getDigestFragmentsForRestrictionEnzymes(
-  sequence,
-  circular,
-  restrictionEnzymeOrEnzymes,
-  opts
-) {
-  const restrictionEnzymes = Array.isArray(restrictionEnzymeOrEnzymes)
-    ? restrictionEnzymeOrEnzymes
-    : [restrictionEnzymeOrEnzymes];
-  const cutsites = flatMap(restrictionEnzymes, restrictionEnzyme => {
-    return cutSequenceByRestrictionEnzyme(
-      sequence,
-      circular,
-      restrictionEnzyme
-    );
-  });
-  return getDigestFragmentsForCutsites(
-    sequence.length,
-    circular,
-    cutsites,
-    opts
-  );
-}

package/src/getReverseComplementSequenceAndAnnotations.js

@@ -1,40 +0,0 @@
-import getReverseComplementSequenceString from "./getReverseComplementSequenceString";
-import getReverseComplementAnnotation from "./getReverseComplementAnnotation";
-import { annotationTypes } from "./annotationTypes";
-import { map } from "lodash-es";
-import tidyUpSequenceData from "./tidyUpSequenceData";
-
-import getSequenceDataBetweenRange from "./getSequenceDataBetweenRange";
-
-// ac.throw([ac.string,ac.bool],arguments);
-export default function getReverseComplementSequenceAndAnnoations(
-  pSeqObj,
-  options = {}
-) {
-  const seqObj = tidyUpSequenceData(
-    getSequenceDataBetweenRange(pSeqObj, options.range),
-    { doNotRemoveInvalidChars: true, ...options }
-  );
-  const newSeqObj = Object.assign(
-    {},
-    seqObj,
-    {
-      sequence: getReverseComplementSequenceString(seqObj.sequence)
-    },
-    annotationTypes.reduce((acc, type) => {
-      if (seqObj[type]) {
-        acc[type] = map(seqObj[type], annotation => {
-          return getReverseComplementAnnotation(
-            annotation,
-            seqObj.sequence.length
-          );
-        });
-      }
-      return acc;
-    }, {})
-  );
-  return tidyUpSequenceData(newSeqObj, {
-    doNotRemoveInvalidChars: true,
-    ...options
-  });
-}

package/src/isEnzymeType2S.js

@@ -1,3 +0,0 @@
-export default function isEnzymeType2S(e) {
-  return e.site.length < e.topSnipOffset || e.site.length < e.bottomSnipOffset;
-}

package/src/mapAnnotationsToRows.js

@@ -1,174 +0,0 @@
-import { each, forEach, startsWith, filter } from "lodash-es";
-
-import {
-  getYOffsetForPotentiallyCircularRange,
-  splitRangeIntoTwoPartsIfItIsCircular
-} from "@teselagen/range-utils";
-
-export default function mapAnnotationsToRows(
-  annotations,
-  sequenceLength,
-  bpsPerRow,
-  { splitForwardReverse } = {}
-) {
-  const annotationsToRowsMap = {};
-  const yOffsetLevelMap = {};
-  const wrappedAnnotations = {};
-  each(annotations, annotation => {
-    const containsLocations = !!(
-      annotation.locations && annotation.locations.length
-    );
-    if (annotation.overlapsSelf) {
-      //if the annotation overlaps itself, first send a fake full spanning annotation thru the mapping function
-      if (!wrappedAnnotations[annotation.id]) {
-        mapAnnotationToRows({
-          wrappedAnnotations,
-          annotation: {
-            start: 0,
-            end: sequenceLength - 1,
-            id: `__tempAnnRemoveMe__${annotation.id}`
-          },
-          sequenceLength,
-          bpsPerRow,
-          annotationsToRowsMap,
-          yOffsetLevelMap,
-          containsLocations,
-          splitForwardReverse
-        });
-        wrappedAnnotations[annotation.id] = true;
-        // annotation.yOffset = wrappedAnnotations[annotation.id];
-      }
-    }
-
-    mapAnnotationToRows({
-      wrappedAnnotations,
-      annotation,
-      sequenceLength,
-      bpsPerRow,
-      annotationsToRowsMap,
-      yOffsetLevelMap,
-      containsLocations,
-      splitForwardReverse
-    });
-    if (containsLocations) {
-      annotation.locations.forEach(location => {
-        mapAnnotationToRows({
-          wrappedAnnotations,
-          annotation,
-          sequenceLength,
-          bpsPerRow,
-          annotationsToRowsMap,
-          yOffsetLevelMap,
-          location,
-          splitForwardReverse
-        });
-      });
-    }
-  });
-  forEach(annotationsToRowsMap, (annotationsForRow, i) => {
-    annotationsToRowsMap[i] = filter(
-      annotationsForRow,
-      ann => !startsWith(ann.id, "__tempAnnRemoveMe__")
-    );
-  });
-  return annotationsToRowsMap;
-}
-
-function mapAnnotationToRows({
-  annotation,
-  sequenceLength,
-  bpsPerRow,
-  annotationsToRowsMap,
-  yOffsetLevelMap,
-  location,
-  containsLocations,
-  splitForwardReverse
-}) {
-  const ranges = splitRangeIntoTwoPartsIfItIsCircular(
-    location || annotation,
-    sequenceLength
-  );
-  ranges.forEach((range, index) => {
-    // if (!isPositiveInteger(range.start)) {}
-    const startingRow = Math.floor(range.start / bpsPerRow);
-    const endingRow = Math.floor(range.end / bpsPerRow);
-    // const numberOfRows = endingRow - startingRow + 1;
-    for (let rowNumber = startingRow; rowNumber <= endingRow; rowNumber++) {
-      if (!annotationsToRowsMap[rowNumber]) {
-        annotationsToRowsMap[rowNumber] = [];
-      }
-      const key = splitForwardReverse
-        ? annotation.forward
-          ? rowNumber + "_forward"
-          : rowNumber + "_reverse"
-        : rowNumber;
-
-      const annotationsForRow = annotationsToRowsMap[rowNumber];
-      if (!yOffsetLevelMap[key]) {
-        yOffsetLevelMap[key] = [];
-      }
-
-      let yOffset;
-      const yOffsetsForRow = yOffsetLevelMap[key];
-      const start =
-        rowNumber === startingRow ? range.start : rowNumber * bpsPerRow;
-      const end =
-        rowNumber === endingRow
-          ? range.end
-          : rowNumber * bpsPerRow + bpsPerRow - 1;
-      if (annotation.overlapsSelf) {
-        annotationsForRow.forEach(ann => {
-          if (ann.id === `__tempAnnRemoveMe__${annotation.id}`) {
-            yOffset = ann.yOffset;
-          }
-        });
-      } else {
-        if (location) {
-          //if there's a location then we will just use the previous yOffset for its parent annotation
-          annotationsForRow.forEach(ann => {
-            if (ann.id === annotation.id) {
-              yOffset = ann.yOffset;
-            }
-          });
-        } else {
-          //we need to pass both ranges into this function so that we can correctly
-          //get the y-offset for circular features that start and end on the same row
-          //we pass the entire annotation range here and compare it only with ranges that have already been added to the row
-          if (
-            index > 0 && //second half of an annotation range
-            annotationsForRow.length && //there are already annotations within the row
-            annotationsForRow[annotationsForRow.length - 1].annotation ===
-              annotation
-          ) {
-            //the first chunk of the annotation has already been pushed into the row,
-            //so set the yOffset for the range chunk to the already calculated yOffset
-            yOffset = annotationsForRow[annotationsForRow.length - 1].yOffset;
-          } else {
-            yOffset = getYOffsetForPotentiallyCircularRange(
-              annotation,
-              yOffsetsForRow
-            );
-          }
-          //add the new yOffset to the yOffset array
-          if (!yOffsetsForRow[yOffset]) yOffsetsForRow[yOffset] = [];
-          yOffsetsForRow[yOffset].push({
-            start: start,
-            end: end
-          });
-        }
-      }
-
-      annotationsForRow.push({
-        id: annotation.id,
-        annotation: annotation,
-        start: start,
-        end: end,
-        ...(containsLocations && { containsLocations }),
-        ...(location && { isJoinedLocation: !!location }),
-        yOffset: yOffset,
-        enclosingRangeType: range.type //either "beginning", "end" or "beginningAndEnd"
-      });
-    }
-  });
-  // return annotationsToRowsMap;
-}

package/src/prepareCircularViewData.js

@@ -1,17 +0,0 @@
-import { cloneDeep } from "lodash-es";
-import { getYOffsetsForPotentiallyCircularRanges } from "@teselagen/range-utils";
-import { annotationTypes } from "./annotationTypes";
-
-//basically just adds yOffsets to the annotations
-export default function prepareCircularViewData(sequenceData) {
-  const clonedSeqData = cloneDeep(sequenceData);
-  annotationTypes.forEach(annotationType => {
-    if (annotationType !== "cutsites") {
-      const maxYOffset = getYOffsetsForPotentiallyCircularRanges(
-        clonedSeqData[annotationType]
-      ).maxYOffset;
-      clonedSeqData[annotationType].maxYOffset = maxYOffset;
-    }
-  });
-  return clonedSeqData;
-}

package/src/rotateBpsToPosition.js

@@ -1,9 +0,0 @@
-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/shiftAnnotationsByLen.js

@@ -1,17 +0,0 @@
-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/tidyUpSequenceData.test.d.ts

@@ -1 +0,0 @@
-export {};