@teselagen/range-utils 0.3.6 → 0.3.8

package/README.md

@@ -0,0 +1,94 @@
+<!-- TOC -->
+
+- [[CHANGELOG](Changelog.md)](#changelogchangelogmd)
+- [Installing](#installing)
+- [Usage](#usage)
+- [About this Repo](#about-this-repo)
+- [Editing This Repo:](#editing-this-repo)
+  - [All collaborators:](#all-collaborators)
+- [Updating this repo:](#updating-this-repo)
+  - [Teselagen collaborators:](#teselagen-collaborators)
+  - [Outside collaborators:](#outside-collaborators)
+- [Building](#building)
+- [Running unit tests](#running-unit-tests)
+
+<!-- /TOC -->
+
+## [CHANGELOG](Changelog.md)
+
+## Installing
+
+```
+npm install @teselagen/range-utils
+```
+
+## Usage
+
+```
+import { getRangeLength } from '@teselagen/range-utils';
+```
+
+## About this Repo
+
+This is a collection of range utility functions.
+
+A range must be an object with a start and end property.
+Eg:
+
+```
+const myRange = {
+	start: 10,
+	end: 40
+}
+```
+
+A "circular" range has a start > end.
+Eg:
+
+```
+const myRange2 = {
+	start: 50,
+	end: 40
+}
+```
+
+All ranges are assumed to have 0-based inclusive indices:
+
+rrrr
+0123
+start = 0,
+end = 3
+
+## Editing This Repo:
+
+### All collaborators:
+
+Edit/create a new file and update/add any relevant tests.
+You can run `npm test` to make sure all tests pass.
+Tests will automatically be run pre-commit.
+
+## Updating this repo:
+
+### Teselagen collaborators:
+
+Commit and push all changes
+Sign into npm using the teselagen npm account (npm whoami)
+
+```
+npm version patch|minor|major
+npm publish
+```
+
+### Outside collaborators:
+
+fork and pull request please :)
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build range-utils` to build the library.
+
+## Running unit tests
+
+Run `nx test range-utils` to execute the unit tests via [Jest](https://jestjs.io).

package/flipContainedRange.d.ts

@@ -1 +1 @@
-export default function flipRelativeRange(innerRange: any, outerRange: any, sequenceLength: any, options: any): any;
+export default function flipRelativeRange(innerRange: any, outerRange: any, sequenceLength: any): any;

package/index.js

@@ -6047,8 +6047,8 @@ function getOverlapsOfPotentiallyCircularRanges(rangeA, rangeB, maxRangeLength,
     maxRangeLength
   );
   let overlaps = [];
-  normalizedRangeA.forEach(function(nonCircularRangeA, iA) {
-    normalizedRangeB.forEach(function(nonCircularRangeB, iB) {
+  normalizedRangeA.forEach(function(nonCircularRangeA) {
+    normalizedRangeB.forEach(function(nonCircularRangeB) {
       const overlap = getOverlapOfNonCircularRanges(
         nonCircularRangeA,
         nonCircularRangeB
@@ -6060,7 +6060,7 @@ function getOverlapsOfPotentiallyCircularRanges(rangeA, rangeB, maxRangeLength,
   });
   if (joinIfPossible && normalizedRangeA.length === 2 && normalizedRangeB.length === 2 && maxRangeLength) {
     const joinedOverlap = {};
-    overlaps = lodashExports.flatMap(overlaps, (o, i) => {
+    overlaps = lodashExports.flatMap(overlaps, (o) => {
       if (o.start === 0) {
         joinedOverlap.end = o.end;
         return [];
@@ -6158,12 +6158,14 @@ function trimRangeByAnotherRange(rangeToBeTrimmed, trimmingRange, sequenceLength
     });
     splitRangesToBeTrimmed[index] = nonCircularRangeToBeTrimmed;
   });
-  const outputSplitRanges = splitRangesToBeTrimmed.filter(function(trimmedRange) {
-    if (trimmedRange) {
-      return true;
+  const outputSplitRanges = splitRangesToBeTrimmed.filter(
+    function(trimmedRange) {
+      if (trimmedRange) {
+        return true;
+      }
+      return false;
     }
-    return false;
-  });
+  );
   let outputTrimmedRange;
   if (outputSplitRanges.length < 0)
     ;
@@ -6262,11 +6264,19 @@ function checkIfNonCircularRangesOverlap(range, comparisonRange) {
 }
 __name(checkIfNonCircularRangesOverlap, "checkIfNonCircularRangesOverlap");
 function checkIfPotentiallyCircularRangesOverlap(range, comparisonRange) {
-  return splitRangeIntoTwoPartsIfItIsCircular(range, Infinity).some(function(splitRange) {
-    return splitRangeIntoTwoPartsIfItIsCircular(comparisonRange, Infinity).some(function(splitComparisonRange) {
-      return checkIfNonCircularRangesOverlap(splitRange, splitComparisonRange);
-    });
-  });
+  return splitRangeIntoTwoPartsIfItIsCircular(range, Infinity).some(
+    function(splitRange) {
+      return splitRangeIntoTwoPartsIfItIsCircular(
+        comparisonRange,
+        Infinity
+      ).some(function(splitComparisonRange) {
+        return checkIfNonCircularRangesOverlap(
+          splitRange,
+          splitComparisonRange
+        );
+      });
+    }
+  );
 }
 __name(checkIfPotentiallyCircularRangesOverlap, "checkIfPotentiallyCircularRangesOverlap");
 function collapseOverlapsGeneratedFromRangeComparisonIfPossible(overlaps, sequenceLength, optionalOriginalRange) {
@@ -6275,15 +6285,19 @@ function collapseOverlapsGeneratedFromRangeComparisonIfPossible(overlaps, sequen
     return overlaps;
   } else if (overlaps.length === 2) {
     if (overlaps[0].start === 0 && overlaps[1].end + 1 === sequenceLength && !originalRangeLinear) {
-      return [{
-        start: overlaps[1].start,
-        end: overlaps[0].end
-      }];
+      return [
+        {
+          start: overlaps[1].start,
+          end: overlaps[0].end
+        }
+      ];
     } else if (overlaps[1].start === 0 && overlaps[0].end + 1 === sequenceLength && !originalRangeLinear) {
-      return [{
-        start: overlaps[0].start,
-        end: overlaps[1].end
-      }];
+      return [
+        {
+          start: overlaps[0].start,
+          end: overlaps[1].end
+        }
+      ];
     } else {
       return overlaps;
     }
@@ -6291,17 +6305,29 @@ function collapseOverlapsGeneratedFromRangeComparisonIfPossible(overlaps, sequen
     const firstOverlap = overlaps[0];
     const secondOverlap = overlaps[1];
     const thirdOverlap = overlaps[2];
-    let collapsedOverlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible([firstOverlap, secondOverlap], sequenceLength, optionalOriginalRange);
+    let collapsedOverlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible(
+      [firstOverlap, secondOverlap],
+      sequenceLength,
+      optionalOriginalRange
+    );
     if (collapsedOverlaps.length === 1) {
       collapsedOverlaps.push(thirdOverlap);
       return collapsedOverlaps;
     } else {
-      collapsedOverlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible([firstOverlap, thirdOverlap], sequenceLength, optionalOriginalRange);
+      collapsedOverlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible(
+        [firstOverlap, thirdOverlap],
+        sequenceLength,
+        optionalOriginalRange
+      );
       if (collapsedOverlaps.length === 1) {
         collapsedOverlaps.push(secondOverlap);
         return collapsedOverlaps;
       } else {
-        collapsedOverlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible([secondOverlap, thirdOverlap], sequenceLength, optionalOriginalRange);
+        collapsedOverlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible(
+          [secondOverlap, thirdOverlap],
+          sequenceLength,
+          optionalOriginalRange
+        );
         if (collapsedOverlaps.length === 1) {
           collapsedOverlaps.push(firstOverlap);
           return collapsedOverlaps;
@@ -6323,11 +6349,18 @@ function convertRangeIndices(range, inputType, outputType) {
 }
 __name(convertRangeIndices, "convertRangeIndices");
 function convertRangeTo0Based(range) {
-  return convertRangeIndices(range, { inclusive1BasedStart: true, inclusive1BasedEnd: true });
+  return convertRangeIndices(range, {
+    inclusive1BasedStart: true,
+    inclusive1BasedEnd: true
+  });
 }
 __name(convertRangeTo0Based, "convertRangeTo0Based");
 function convertRangeTo1Based(range) {
-  return convertRangeIndices(range, {}, { inclusive1BasedStart: true, inclusive1BasedEnd: true });
+  return convertRangeIndices(
+    range,
+    {},
+    { inclusive1BasedStart: true, inclusive1BasedEnd: true }
+  );
 }
 __name(convertRangeTo1Based, "convertRangeTo1Based");
 function provideInclusiveOptions(funToWrap) {
@@ -6442,7 +6475,11 @@ function expandOrContractCircularRangeToPosition(range, position, maxLength) {
   let endMoved = true;
   if (range.end >= position) {
     if (position + maxLength - range.start > range.end - position) {
-      newRange.end = normalizePositionByRangeLength(position - 1, maxLength, false);
+      newRange.end = normalizePositionByRangeLength(
+        position - 1,
+        maxLength,
+        false
+      );
     } else {
       newRange.start = position;
       endMoved = false;
@@ -6515,19 +6552,32 @@ function expandOrContractRangeToPosition(range, position, maxLength) {
   if (range.start > range.end) {
     return expandOrContractCircularRangeToPosition(range, position, maxLength);
   } else {
-    return expandOrContractNonCircularRangeToPosition(range, position);
+    return expandOrContractNonCircularRangeToPosition(
+      range,
+      position
+    );
   }
 }
 __name(expandOrContractRangeToPosition, "expandOrContractRangeToPosition");
 function translateRange(rangeToBeAdjusted, translateBy, rangeLength) {
   return lodashExports.assign({}, rangeToBeAdjusted, {
-    start: normalizePositionByRangeLength(rangeToBeAdjusted.start + translateBy, rangeLength),
-    end: normalizePositionByRangeLength(rangeToBeAdjusted.end + translateBy, rangeLength)
+    start: normalizePositionByRangeLength(
+      rangeToBeAdjusted.start + translateBy,
+      rangeLength
+    ),
+    end: normalizePositionByRangeLength(
+      rangeToBeAdjusted.end + translateBy,
+      rangeLength
+    )
   });
 }
 __name(translateRange, "translateRange");
-function flipRelativeRange(innerRange, outerRange, sequenceLength, options) {
-  const isFullyContained = isRangeWithinRange(innerRange, outerRange, sequenceLength);
+function flipRelativeRange(innerRange, outerRange, sequenceLength) {
+  const isFullyContained = isRangeWithinRange(
+    innerRange,
+    outerRange,
+    sequenceLength
+  );
   if (isFullyContained) {
     return flipFullyContainedRange(innerRange, outerRange, sequenceLength);
   } else {
@@ -6535,42 +6585,92 @@ function flipRelativeRange(innerRange, outerRange, sequenceLength, options) {
   }
 }
 __name(flipRelativeRange, "flipRelativeRange");
-function flipNonFullyContainedRange(innerRange, outerRange, sequenceLength, options) {
-  const outerFullyContained = isRangeWithinRange(outerRange, innerRange, sequenceLength);
+function flipNonFullyContainedRange(innerRange, outerRange, sequenceLength) {
+  const outerFullyContained = isRangeWithinRange(
+    outerRange,
+    innerRange,
+    sequenceLength
+  );
   let flippedInnerRange;
   if (outerFullyContained) {
-    const expandBy1 = getRangeLength({
-      start: innerRange.start,
-      end: outerRange.start
-    }, sequenceLength) - 1;
-    flippedInnerRange = expandOrContractRangeByLength(outerRange, expandBy1, false, sequenceLength);
-    const expandBy2 = getRangeLength({
-      end: innerRange.end,
-      start: outerRange.end
-    }, sequenceLength) - 1;
-    flippedInnerRange = expandOrContractRangeByLength(flippedInnerRange, expandBy2, true, sequenceLength);
+    const expandBy1 = getRangeLength(
+      {
+        start: innerRange.start,
+        end: outerRange.start
+      },
+      sequenceLength
+    ) - 1;
+    flippedInnerRange = expandOrContractRangeByLength(
+      outerRange,
+      expandBy1,
+      false,
+      sequenceLength
+    );
+    const expandBy2 = getRangeLength(
+      {
+        end: innerRange.end,
+        start: outerRange.end
+      },
+      sequenceLength
+    ) - 1;
+    flippedInnerRange = expandOrContractRangeByLength(
+      flippedInnerRange,
+      expandBy2,
+      true,
+      sequenceLength
+    );
   } else {
-    const overlaps = getOverlapsOfPotentiallyCircularRanges(innerRange, outerRange, sequenceLength);
+    const overlaps = getOverlapsOfPotentiallyCircularRanges(
+      innerRange,
+      outerRange,
+      sequenceLength
+    );
     if (overlaps.length >= 1) {
-      let overlapExtendsForward;
       const firstOverlap = overlaps[0];
-      overlapExtendsForward = firstOverlap.start !== outerRange.start;
-      const flippedTruncatedInner = flipFullyContainedRange(firstOverlap, outerRange, sequenceLength);
+      const overlapExtendsForward = firstOverlap.start !== outerRange.start;
+      const flippedTruncatedInner = flipFullyContainedRange(
+        firstOverlap,
+        outerRange,
+        sequenceLength
+      );
       const lengthToExtend = getRangeLength(innerRange, sequenceLength) - getRangeLength(flippedTruncatedInner, sequenceLength);
-      flippedInnerRange = expandOrContractRangeByLength(flippedTruncatedInner, lengthToExtend, overlapExtendsForward, sequenceLength);
+      flippedInnerRange = expandOrContractRangeByLength(
+        flippedTruncatedInner,
+        lengthToExtend,
+        overlapExtendsForward,
+        sequenceLength
+      );
     } else {
-      throw new Error("This case (relative ranges that do not overlap) is unsupported! ");
+      throw new Error(
+        "This case (relative ranges that do not overlap) is unsupported! "
+      );
     }
   }
   return flippedInnerRange;
 }
 __name(flipNonFullyContainedRange, "flipNonFullyContainedRange");
-function flipFullyContainedRange(innerRange, outerRange, sequenceLength, options) {
+function flipFullyContainedRange(innerRange, outerRange, sequenceLength) {
   const translateBy = -outerRange.start;
-  const translatedOuterRange = translateRange(outerRange, translateBy, sequenceLength);
-  const translatedInnerRange = translateRange(innerRange, translateBy, sequenceLength);
-  const translatedFlippedInnerRange = flipNonOriginSpanningContainedRange(translatedInnerRange, translatedOuterRange, sequenceLength);
-  const flippedInnerRange = translateRange(translatedFlippedInnerRange, -translateBy, sequenceLength);
+  const translatedOuterRange = translateRange(
+    outerRange,
+    translateBy,
+    sequenceLength
+  );
+  const translatedInnerRange = translateRange(
+    innerRange,
+    translateBy,
+    sequenceLength
+  );
+  const translatedFlippedInnerRange = flipNonOriginSpanningContainedRange(
+    translatedInnerRange,
+    translatedOuterRange,
+    sequenceLength
+  );
+  const flippedInnerRange = translateRange(
+    translatedFlippedInnerRange,
+    -translateBy,
+    sequenceLength
+  );
   return flippedInnerRange;
 }
 __name(flipFullyContainedRange, "flipFullyContainedRange");
@@ -6588,7 +6688,10 @@ function generateRandomRange(minStart, maxEnd, maxLength) {
   const start = getRandomInt(minStart, maxEnd);
   let end;
   if (maxLength) {
-    end = normalizePositionByRangeLength(getRandomInt(start, start + maxLength), maxEnd);
+    end = normalizePositionByRangeLength(
+      getRandomInt(start, start + maxLength),
+      maxEnd
+    );
   } else {
     end = getRandomInt(minStart, maxEnd);
   }
@@ -6640,7 +6743,11 @@ function getEachPositionInRangeAsArray(range, rangeMax) {
 }
 __name(getEachPositionInRangeAsArray, "getEachPositionInRangeAsArray");
 function getLengthOfOverlappingRegionsBetweenTwoRanges(rangeA, rangeB, maxLength) {
-  const overlaps = getOverlapsOfPotentiallyCircularRanges(rangeA, rangeB, maxLength);
+  const overlaps = getOverlapsOfPotentiallyCircularRanges(
+    rangeA,
+    rangeB,
+    maxLength
+  );
   return overlaps.reduce(function(counter, overlap) {
     return counter + getRangeLength(overlap, maxLength);
   }, 0);
@@ -6693,13 +6800,16 @@ function getRangesBetweenTwoRanges(range1, range2) {
   if (!(range1.start > -1 && range1.end > -1 && range2.start > -1 && range2.end > -1)) {
     return newRanges;
   }
-  return [{
-    start: range1.start,
-    end: range2.end
-  }, {
-    start: range2.start,
-    end: range1.end
-  }];
+  return [
+    {
+      start: range1.start,
+      end: range2.end
+    },
+    {
+      start: range2.start,
+      end: range1.end
+    }
+  ];
 }
 __name(getRangesBetweenTwoRanges, "getRangesBetweenTwoRanges");
 function getSequenceWithinRange(range, sequence) {
@@ -6731,18 +6841,26 @@ function getShortestDistanceBetweenTwoPositions(position1, position2, sequenceLe
 __name(getShortestDistanceBetweenTwoPositions, "getShortestDistanceBetweenTwoPositions");
 function getYOffsetForPotentiallyCircularRange(range, YOffsetLevelsWithRanges, assignYOffsetToRange) {
   let yOffset = [];
-  const openYOffsetFound = YOffsetLevelsWithRanges.some(function(rangesAlreadyAddedToYOffset, index) {
-    const rangeBlocked = rangesAlreadyAddedToYOffset.some(function(comparisonRange) {
-      return checkIfPotentiallyCircularRangesOverlap(range, comparisonRange);
-    });
-    if (!rangeBlocked) {
-      yOffset = index;
-      if (assignYOffsetToRange)
-        range.yOffset = index;
-      rangesAlreadyAddedToYOffset.push(range);
-      return true;
+  const openYOffsetFound = YOffsetLevelsWithRanges.some(
+    function(rangesAlreadyAddedToYOffset, index) {
+      const rangeBlocked = rangesAlreadyAddedToYOffset.some(
+        function(comparisonRange) {
+          return checkIfPotentiallyCircularRangesOverlap(
+            range,
+            comparisonRange
+          );
+        }
+      );
+      if (!rangeBlocked) {
+        yOffset = index;
+        if (assignYOffsetToRange)
+          range.yOffset = index;
+        rangesAlreadyAddedToYOffset.push(range);
+        return true;
+      }
+      return false;
     }
-  });
+  );
   if (!openYOffsetFound) {
     yOffset = YOffsetLevelsWithRanges.length;
     if (assignYOffsetToRange)
@@ -6756,7 +6874,11 @@ function getYOffsetsForPotentiallyCircularRanges(ranges, assignYOffsetToRange) {
   let maxYOffset = 0;
   const yOffsetLevels = [];
   ranges.forEach(function(range) {
-    const yOffset = getYOffsetForPotentiallyCircularRange(range, yOffsetLevels, assignYOffsetToRange);
+    const yOffset = getYOffsetForPotentiallyCircularRange(
+      range,
+      yOffsetLevels,
+      assignYOffsetToRange
+    );
     yOffsets.push(yOffset);
     if (yOffset > maxYOffset) {
       maxYOffset = yOffset;
@@ -6789,8 +6911,16 @@ function invertRange$1(rangeOrCaret, rangeMax) {
 }
 __name(invertRange$1, "invertRange$1");
 function isPositionCloserToRangeStartThanRangeEnd(position, range, maxLength) {
-  const distanceFromStart = getShortestDistanceBetweenTwoPositions(range.start, position, maxLength);
-  const distanceFromEnd = getShortestDistanceBetweenTwoPositions(range.end, position, maxLength);
+  const distanceFromStart = getShortestDistanceBetweenTwoPositions(
+    range.start,
+    position,
+    maxLength
+  );
+  const distanceFromEnd = getShortestDistanceBetweenTwoPositions(
+    range.end,
+    position,
+    maxLength
+  );
   return distanceFromStart <= distanceFromEnd;
 }
 __name(isPositionCloserToRangeStartThanRangeEnd, "isPositionCloserToRangeStartThanRangeEnd");
@@ -6835,9 +6965,15 @@ function trimNumberToFitWithin0ToAnotherNumber(numberToBeTrimmed, max) {
 }
 __name(trimNumberToFitWithin0ToAnotherNumber, "trimNumberToFitWithin0ToAnotherNumber");
 function zeroSubrangeByContainerRange(subRange, containerRange, sequenceLength) {
-  const trimmedSubRange = trimRangeByAnotherRange(subRange, containerRange, sequenceLength);
+  const trimmedSubRange = trimRangeByAnotherRange(
+    subRange,
+    containerRange,
+    sequenceLength
+  );
   if (trimmedSubRange) {
-    throw new Error("subRange must be fully contained by containerRange! Otherwise this function does not make sense");
+    throw new Error(
+      "subRange must be fully contained by containerRange! Otherwise this function does not make sense"
+    );
   }
   const newSubrange = {};
   newSubrange.start = subRange.start - containerRange.start;
@@ -6865,12 +7001,24 @@ function modulo(n, m) {
 }
 __name(modulo, "modulo");
 function getZeroedRangeOverlaps(annotation, selection, sequenceLength) {
-  const overlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible(getOverlapsOfPotentiallyCircularRanges(annotation, selection, sequenceLength), sequenceLength, annotation);
+  const overlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible(
+    getOverlapsOfPotentiallyCircularRanges(
+      annotation,
+      selection,
+      sequenceLength
+    ),
+    sequenceLength,
+    annotation
+  );
   const zeroedOverlaps = overlaps.map((overlap) => {
-    return zeroSubrangeByContainerRange(overlap, {
-      start: selection.start,
-      end: normalizePositionByRangeLength(selection.start - 1, sequenceLength)
-    }, sequenceLength);
+    return zeroSubrangeByContainerRange(
+      overlap,
+      {
+        start: selection.start,
+        end: normalizePositionByRangeLength(selection.start - 1, sequenceLength)
+      },
+      sequenceLength
+    );
   });
   return zeroedOverlaps;
 }