@teselagen/range-utils 0.3.20-beta.1 → 0.3.20

package/src/{adjustRangeToInsert.ts → adjustRangeToInsert.js}

@@ -1,11 +1,11 @@
 import { assign } from "lodash-es";
-import { Range } from "./types";
 
 export default function adjustRangeToInsert(
-  rangeToBeAdjusted: Range,
-  insertStart: number,
-  insertLength: number
+  rangeToBeAdjusted,
+  insertStart,
+  insertLength
 ) {
+  // ac.throw([ac.range, ac.posInt, ac.posInt], arguments);
   const newRange = assign({}, rangeToBeAdjusted);
   if (rangeToBeAdjusted.start > rangeToBeAdjusted.end) {
     //circular range

package/src/adjustRangeToRotation.js

@@ -0,0 +1,23 @@
+import { assign } from "lodash-es";
+
+import { identity } from "lodash-es";
+
+export default function adjustRangeToRotation(
+  rangeToBeAdjusted,
+  rotateTo = 0,
+  rangeLength
+) {
+  // ac.throw([ac.range, ac.posInt, ac.posInt], arguments);
+  const mod = rangeLength ? modulo : identity;
+
+  const newRange = assign({}, rangeToBeAdjusted, {
+    start: mod(rangeToBeAdjusted.start - (rotateTo || 0), rangeLength),
+    end: mod(rangeToBeAdjusted.end - (rotateTo || 0), rangeLength)
+  });
+
+  return newRange;
+}
+
+function modulo(n, m) {
+  return ((n % m) + m) % m;
+}

package/src/{checkIfNonCircularRangesOverlap.ts → checkIfNonCircularRangesOverlap.js}

@@ -1,11 +1,10 @@
-import { Range } from "./types";
-
 //
-
+// ac.throw([ac.posInt, ac.posInt, ac.bool], arguments);
 export default function checkIfNonCircularRangesOverlap(
-  range: Range,
-  comparisonRange: Range
+  range,
+  comparisonRange
 ) {
+  // ac.throw([ac.range, ac.range], arguments);
   if (range.start < comparisonRange.start) {
     if (range.end < comparisonRange.start) {
       //----llll

package/src/{checkIfPotentiallyCircularRangesOverlap.ts → checkIfPotentiallyCircularRangesOverlap.js}

@@ -1,14 +1,14 @@
 //
-//
 import checkIfNonCircularRangesOverlap from "./checkIfNonCircularRangesOverlap";
 
 import splitRangeIntoTwoPartsIfItIsCircular from "./splitRangeIntoTwoPartsIfItIsCircular";
-import { Range } from "./types";
+// ac.throw([ac.posInt, ac.posInt, ac.bool], arguments);
 
 export default function checkIfPotentiallyCircularRangesOverlap(
-  range: Range,
-  comparisonRange: Range
+  range,
+  comparisonRange
 ) {
+  // ac.throw([ac.range, ac.range], arguments);
   //split the potentially circular ranges and compare each part for overlap
   return splitRangeIntoTwoPartsIfItIsCircular(range, Infinity).some(
     function (splitRange) {

package/src/{collapseOverlapsGeneratedFromRangeComparisonIfPossible.ts → collapseOverlapsGeneratedFromRangeComparisonIfPossible.js}

@@ -1,12 +1,10 @@
-import { Range } from "./types";
-
 //this function is a little confusing, but basically it takes an array of overlaps
 //generated from a range overlaps calculation, and it sews them together if possible
 export default function collapseOverlapsGeneratedFromRangeComparisonIfPossible(
-  overlaps: Range[],
-  sequenceLength: number,
-  optionalOriginalRange?: Range
-): Range[] {
+  overlaps,
+  sequenceLength,
+  optionalOriginalRange
+) {
   const originalRangeLinear =
     optionalOriginalRange &&
     optionalOriginalRange.start <= optionalOriginalRange.end;
@@ -77,5 +75,4 @@ export default function collapseOverlapsGeneratedFromRangeComparisonIfPossible(
       }
     }
   }
-  return overlaps;
 }

package/src/{convertRangeIndices.ts → convertRangeIndices.js}

@@ -1,16 +1,8 @@
 import { assign } from "lodash-es";
-import { Range } from "./types";
 
-interface RangeIndicesOptions {
-  inclusive1BasedStart?: boolean;
-  inclusive1BasedEnd?: boolean;
-}
-
-export default function convertRangeIndices(
-  range: Range,
-  inputType: RangeIndicesOptions = {},
-  outputType: RangeIndicesOptions = {}
-) {
+export default function convertRangeIndices(range, inputType, outputType) {
+  inputType = inputType || {};
+  outputType = outputType || {};
   return assign({}, range, {
     start:
       Number(range.start) +

package/src/{convertRangeTo0Based.ts → convertRangeTo0Based.js}

@@ -1,7 +1,6 @@
 import convertRangeIndices from "./convertRangeIndices";
-import { Range } from "./types";
 
-export default function convertRangeTo0Based(range: Range) {
+export default function convertRangeTo0Based(range) {
   return convertRangeIndices(range, {
     inclusive1BasedStart: true,
     inclusive1BasedEnd: true

package/src/{convertRangeTo1Based.ts → convertRangeTo1Based.js}

@@ -1,7 +1,6 @@
 import convertRangeIndices from "./convertRangeIndices";
-import { Range } from "./types";
 
-export default function convertRangeTo1Based(range: Range) {
+export default function convertRangeTo1Based(range) {
   return convertRangeIndices(
     range,
     {},

package/src/doesRangeSpanEntireSequence.js

@@ -0,0 +1,7 @@
+import getRangeLength from "./getRangeLength";
+
+export default function doesRangeSpanEntireSequence(range, sequenceLength) {
+  if (getRangeLength(range) === sequenceLength) {
+    return true;
+  }
+}

package/src/doesRangeSpanOrigin.js

@@ -0,0 +1,3 @@
+export default function doesRangeSpanOrigin(range) {
+  return range.start > range.end;
+}

package/src/{expandOrContractCircularRangeToPosition.ts → expandOrContractCircularRangeToPosition.js}

@@ -1,12 +1,10 @@
 import normalizePositionByRangeLength from "./normalizePositionByRangeLength";
 import { assign } from "lodash-es";
 
-import { Range } from "./types";
-
 export default function expandOrContractCircularRangeToPosition(
-  range: Range,
-  position: number,
-  maxLength: number
+  range,
+  position,
+  maxLength
 ) {
   // 0 1 2 3 4 5 6 7 8 9
   // r r r r r - - r r r

package/src/{expandOrContractNonCircularRangeToPosition.ts → expandOrContractNonCircularRangeToPosition.js}

@@ -1,10 +1,8 @@
 import { assign } from "lodash-es";
 
-import { Range } from "./types";
-
 export default function expandOrContractNonCircularRangeToPosition(
-  range: Range,
-  position: number
+  range,
+  position
 ) {
   const newRange = assign({}, range);
   let endMoved = true;

package/src/{expandOrContractRangeByLength.ts → expandOrContractRangeByLength.js}

@@ -1,12 +1,11 @@
 import { clone } from "lodash-es";
-import { Range } from "./types";
 import normalizeRange from "./normalizeRange";
 
 export default function expandOrContractRangeByLength(
-  range: Range,
-  shiftBy: number,
-  shiftStart: boolean,
-  sequenceLength: number
+  range,
+  shiftBy,
+  shiftStart,
+  sequenceLength
 ) {
   const rangeToReturn = clone(range);
   if (shiftStart) {

package/src/{expandOrContractRangeToPosition.ts → expandOrContractRangeToPosition.js}

@@ -1,16 +1,18 @@
 import expandOrContractCircularRangeToPosition from "./expandOrContractCircularRangeToPosition";
 import expandOrContractNonCircularRangeToPosition from "./expandOrContractNonCircularRangeToPosition";
 
-import { Range } from "./types";
-
 export default function expandOrContractRangeToPosition(
-  range: Range,
-  position: number,
-  maxLength: number
+  range,
+  position,
+  maxLength
 ) {
   if (range.start > range.end) {
     return expandOrContractCircularRangeToPosition(range, position, maxLength);
   } else {
-    return expandOrContractNonCircularRangeToPosition(range, position);
+    return expandOrContractNonCircularRangeToPosition(
+      range,
+      position,
+      maxLength
+    );
   }
 }

package/src/{flipContainedRange.ts → flipContainedRange.js}

@@ -4,12 +4,10 @@ import getOverlapsOfPotentiallyCircularRanges from "./getOverlapsOfPotentiallyCi
 import translateRange from "./translateRange";
 import getRangeLength from "./getRangeLength";
 
-import { Range } from "./types";
-
 export default function flipRelativeRange(
-  innerRange: Range,
-  outerRange: Range,
-  sequenceLength: number
+  innerRange,
+  outerRange,
+  sequenceLength
 ) {
   const isFullyContained = isRangeWithinRange(
     innerRange,
@@ -24,11 +22,7 @@ export default function flipRelativeRange(
   }
 }
 
-function flipNonFullyContainedRange(
-  innerRange: Range,
-  outerRange: Range,
-  sequenceLength: number
-) {
+function flipNonFullyContainedRange(innerRange, outerRange, sequenceLength) {
   const outerFullyContained = isRangeWithinRange(
     outerRange,
     innerRange,
@@ -103,11 +97,7 @@ function flipNonFullyContainedRange(
   return flippedInnerRange;
 }
 
-function flipFullyContainedRange(
-  innerRange: Range,
-  outerRange: Range,
-  sequenceLength: number
-) {
+function flipFullyContainedRange(innerRange, outerRange, sequenceLength) {
   //translate both ranges by offset such that outer range start = 0
   const translateBy = -outerRange.start;
   const translatedOuterRange = translateRange(
@@ -138,9 +128,9 @@ function flipFullyContainedRange(
 }
 
 function flipNonOriginSpanningContainedRange(
-  innerRange: Range,
-  outerRange: Range,
-  sequenceLength: number
+  innerRange,
+  outerRange,
+  sequenceLength
 ) {
   //non origin spanning, fully contained inner
   const offsetFromStart = innerRange.start - outerRange.start;

package/src/{generateRandomRange.ts → generateRandomRange.js}

@@ -1,10 +1,6 @@
 import normalizePositionByRangeLength from "./normalizePositionByRangeLength";
 
-export default function generateRandomRange(
-  minStart: number,
-  maxEnd: number,
-  maxLength: number
-) {
+export default function generateRandomRange(minStart, maxEnd, maxLength) {
   const start = getRandomInt(minStart, maxEnd);
   let end;
   if (maxLength) {
@@ -21,6 +17,6 @@ export default function generateRandomRange(
   };
 }
 
-function getRandomInt(min: number, max: number) {
+function getRandomInt(min, max) {
   return Math.floor(Math.random() * (max - min)) + min;
 }

package/src/{getAnnotationRangeType.ts → getAnnotationRangeType.js}

@@ -1,10 +1,8 @@
-import { Range } from "./types";
-
 //function that returns the annotation range type
 export default function getAnnotationRangeType(
-  annotationRange: Range,
-  enclosingRangeType: Range,
-  forward: boolean
+  annotationRange,
+  enclosingRangeType,
+  forward
 ) {
   if (annotationRange.start === enclosingRangeType.start) {
     if (annotationRange.end === enclosingRangeType.end) {

package/src/{getEachPositionInRangeAsArray.ts → getEachPositionInRangeAsArray.js}

@@ -1,12 +1,8 @@
 import normalizePositionByRangeLength from "./normalizePositionByRangeLength";
 import getRangeLength from "./getRangeLength";
-import { Range } from "./types";
 
-export default function getEachPositionInRangeAsArray(
-  range: Range,
-  rangeMax: number
-) {
-  const output: number[] = [];
+export default function getEachPositionInRangeAsArray(range, rangeMax) {
+  const output = [];
   const length = getRangeLength(range, rangeMax);
   if (!(length > 0)) {
     return output;

package/src/{getLengthOfOverlappingRegionsBetweenTwoRanges.ts → getLengthOfOverlappingRegionsBetweenTwoRanges.js}

@@ -1,11 +1,10 @@
 import getRangeLength from "./getRangeLength";
 import getOverlapsOfPotentiallyCircularRanges from "./getOverlapsOfPotentiallyCircularRanges";
-import { Range } from "./types";
 
 export default function getLengthOfOverlappingRegionsBetweenTwoRanges(
-  rangeA: Range,
-  rangeB: Range,
-  maxLength: number
+  rangeA,
+  rangeB,
+  maxLength
 ) {
   const overlaps = getOverlapsOfPotentiallyCircularRanges(
     rangeA,

package/src/{getMiddleOfRange.ts → getMiddleOfRange.js}

@@ -1,8 +1,7 @@
 import getRangeLength from "./getRangeLength";
 import normalizePositionByRangeLength from "./normalizePositionByRangeLength";
-import { Range } from "./types";
 
-export default function getMiddleOfRange(range: Range, rangeMax: number) {
+export default function getMiddleOfRange(range, rangeMax) {
   const len = getRangeLength({ start: range.start, end: range.end }, rangeMax);
   return normalizePositionByRangeLength(
     range.start + Math.floor(len / 2),

package/src/{getOverlapOfNonCircularRanges.ts → getOverlapOfNonCircularRanges.js}

@@ -1,9 +1,4 @@
-import { Range } from "./types";
-
-export default function getOverlapOfNonCircularRanges(
-  rangeA: Range,
-  rangeB: Range
-) {
+export default function getOverlapOfNonCircularRanges(rangeA, rangeB) {
   if (rangeA.start < rangeB.start) {
     if (rangeA.end < rangeB.start) {
       //no overlap
@@ -37,5 +32,4 @@ export default function getOverlapOfNonCircularRanges(
       }
     }
   }
-  return null;
 }

package/src/{getOverlapsOfPotentiallyCircularRanges.ts → getOverlapsOfPotentiallyCircularRanges.js}

@@ -2,15 +2,12 @@ import { flatMap } from "lodash-es";
 import splitRangeIntoTwoPartsIfItIsCircular from "./splitRangeIntoTwoPartsIfItIsCircular";
 import getOverlapOfNonCircularRanges from "./getOverlapOfNonCircularRanges";
 
-//returns an array of the overlaps between two potentially circular ranges
-import { Range } from "./types";
-
 //returns an array of the overlaps between two potentially circular ranges
 export default function getOverlapsOfPotentiallyCircularRanges(
-  rangeA: Range,
-  rangeB: Range,
-  maxRangeLength: number,
-  joinIfPossible = false //by default this fn only returns **non-circular** overlaps, if true it will try to join overlaps split on the origin
+  rangeA,
+  rangeB,
+  maxRangeLength,
+  joinIfPossible //by default this fn only returns **non-circular** overlaps, if true it will try to join overlaps split on the origin
 ) {
   const normalizedRangeA = splitRangeIntoTwoPartsIfItIsCircular(
     rangeA,
@@ -21,7 +18,7 @@ export default function getOverlapsOfPotentiallyCircularRanges(
     maxRangeLength
   );
 
-  let overlaps: Range[] = [];
+  let overlaps = [];
 
   normalizedRangeA.forEach(function (nonCircularRangeA) {
     normalizedRangeB.forEach(function (nonCircularRangeB) {
@@ -41,7 +38,7 @@ export default function getOverlapsOfPotentiallyCircularRanges(
     maxRangeLength
   ) {
     //we have 2 circular ranges that will have gotten split on the origin, so we'll manually mend those pieces back together
-    const joinedOverlap: Partial<Range> = {};
+    const joinedOverlap = {};
     overlaps = flatMap(overlaps, o => {
       if (o.start === 0) {
         joinedOverlap.end = o.end;
@@ -50,11 +47,8 @@ export default function getOverlapsOfPotentiallyCircularRanges(
         joinedOverlap.start = o.start;
         return [];
       }
-      return [o];
     });
-    if (Object.keys(joinedOverlap).length > 0) {
-      overlaps.push(joinedOverlap as Range);
-    }
+    overlaps.push(joinedOverlap);
   }
   return overlaps;
 }

package/src/{getPositionFromAngle.ts → getPositionFromAngle.js}

@@ -1,7 +1,7 @@
 export default function getPositionFromAngle(
-  angle: number,
-  rangeMax: number,
-  isInBetweenPositions?: boolean
+  angle,
+  rangeMax,
+  isInBetweenPositions
 ) {
   //percent through sequence * rangeMax
   const unroundedPostion = (angle / Math.PI / 2) * rangeMax;

package/src/{getRangeAngles.ts → getRangeAngles.js}

@@ -1,11 +1,6 @@
 import getRangeLength from "./getRangeLength";
-import { Range } from "./types";
-import { RangeAngles } from "./RangeAngles";
 
-export default function getRangeAngles(
-  range: Range,
-  rangeMax: number
-): RangeAngles {
+export default function getRangeAngles(range, rangeMax) {
   const { startAngle, totalAngle, endAngle } = getStartEndAndTotalAngle(
     range,
     rangeMax
@@ -18,13 +13,13 @@ export default function getRangeAngles(
     centerAngle: startAngle + totalAngle / 2,
     locationAngles:
       range.locations &&
-      range.locations.map((location: Range) => {
+      range.locations.map(location => {
         return getRangeAngles(location, rangeMax);
       })
   };
 }
 
-function getStartEndAndTotalAngle(range: Range, rangeMax: number) {
+function getStartEndAndTotalAngle(range, rangeMax) {
   const rangeLength = getRangeLength(
     { start: range.start, end: range.end },
     rangeMax

package/src/{getRangeLength.ts → getRangeLength.js}

@@ -1,9 +1,6 @@
 import provideInclusiveOptions from "./provideInclusiveOptions";
-import { Range } from "./types";
-
 export default provideInclusiveOptions(getRangeLength);
-
-function getRangeLength(range: Range, rangeMax: number) {
+function getRangeLength(range, rangeMax) {
   let toRet;
   if (range.end < range.start) {
     toRet = rangeMax - range.start + range.end + 1;

package/src/{getRangesBetweenTwoRanges.ts → getRangesBetweenTwoRanges.js}

@@ -1,9 +1,4 @@
-import { Range } from "./types";
-
-export default function getRangesBetweenTwoRanges(
-  range1: Range,
-  range2: Range
-) {
+export default function getRangesBetweenTwoRanges(range1, range2) {
   // {
   //     start: 85,
   //     end: 92
@@ -18,7 +13,7 @@ export default function getRangesBetweenTwoRanges(
 
   // start2 - end1
 
-  const newRanges: Range[] = [];
+  const newRanges = [];
   if (
     !(
       range1.start > -1 &&

package/src/getSequenceWithinRange.js

@@ -0,0 +1,17 @@
+//
+export default function getSequenceWithinRange(range, sequence) {
+  // ac.throw([ac.range, ac.oneOfType([ac.array, ac.string])], arguments);
+  if (range.start < 0 || range.end < 0) return "";
+  if (range.start > range.end) {
+    //circular range
+    let subSequence = sequence.slice(range.start, sequence.length);
+    if (typeof subSequence === "string") {
+      subSequence += sequence.slice(0, range.end + 1);
+    } else {
+      subSequence = subSequence.concat(sequence.slice(0, range.end + 1));
+    }
+    return subSequence;
+  } else {
+    return sequence.slice(range.start, range.end + 1);
+  }
+}

package/src/{getShortestDistanceBetweenTwoPositions.ts → getShortestDistanceBetweenTwoPositions.js}

@@ -1,7 +1,7 @@
 export default function getShortestDistanceBetweenTwoPositions(
-  position1: number,
-  position2: number,
-  sequenceLength: number
+  position1,
+  position2,
+  sequenceLength
 ) {
   if (position1 < position2) {
     const position1Holder = position1;

package/src/{getYOffsetForPotentiallyCircularRange.ts → getYOffsetForPotentiallyCircularRange.js}

@@ -1,13 +1,12 @@
 import checkIfPotentiallyCircularRangesOverlap from "./checkIfPotentiallyCircularRangesOverlap";
-import { Range } from "./types";
 
 export default function getYOffsetForPotentiallyCircularRange(
-  range: Range,
-  YOffsetLevelsWithRanges: Range[][],
-  assignYOffsetToRange: boolean
+  range,
+  YOffsetLevelsWithRanges,
+  assignYOffsetToRange
 ) {
   //adjust the yOffset of the range being pushed in by checking its range against other range already in the row
-  let yOffset = 0;
+  let yOffset = [];
   //YOffsetLevelsWithRanges is an array of arrays (array of yOffset levels holding arrays of range)
   //loop through y offset levels starting with the 0 level until an empty one is found and push the range into it. If none are found, add another level.
   const openYOffsetFound = YOffsetLevelsWithRanges.some(

package/src/{getYOffsetsForPotentiallyCircularRanges.ts → getYOffsetsForPotentiallyCircularRanges.js}

@@ -1,14 +1,13 @@
 import getYOffsetForPotentiallyCircularRange from "./getYOffsetForPotentiallyCircularRange";
-import { Range } from "./types";
 
 export default function getYOffsetsForPotentiallyCircularRanges(
-  ranges: Range[],
-  assignYOffsetToRange: boolean
+  ranges,
+  assignYOffsetToRange
 ) {
   //adjust the yOffset of the range being pushed in by checking its range against other ranges already in the row
-  const yOffsets: number[] = [];
+  const yOffsets = [];
   let maxYOffset = 0;
-  const yOffsetLevels: Range[][] = []; //yOffsetLevels is an array of arrays (array of yOffset levels holding arrays of ranges)
+  const yOffsetLevels = []; //yOffsetLevels is an array of arrays (array of yOffset levels holding arrays of ranges)
   ranges.forEach(function (range) {
     //loop through y offset levels starting with the 0 level until an empty one is found and push the range into it. If none are found, add another level.
     const yOffset = getYOffsetForPotentiallyCircularRange(

package/src/getYOffsetsForPotentiallyCircularRanges.test.js

@@ -0,0 +1,42 @@
+import { expect } from "chai";
+import getYOffsetsForPotentiallyCircularRanges from "./getYOffsetsForPotentiallyCircularRanges.js";
+describe("getYOffsetsForPotentiallyCircularRanges", function () {
+  it("returns correct yOffset for overlapping ranges", function () {
+    expect(
+      getYOffsetsForPotentiallyCircularRanges([
+        {
+          start: 5,
+          end: 100
+        },
+        {
+          start: 50,
+          end: 50
+        }
+      ])
+    ).to.deep.equal({ yOffsets: [0, 1], maxYOffset: 1 });
+    expect(
+      getYOffsetsForPotentiallyCircularRanges([
+        {
+          start: 5,
+          end: 100
+        },
+        {
+          start: 50,
+          end: 50
+        },
+        {
+          start: 50,
+          end: 50
+        },
+        {
+          start: 150,
+          end: 4
+        },
+        {
+          start: 150,
+          end: 150
+        }
+      ])
+    ).to.deep.equal({ yOffsets: [0, 1, 2, 0, 1], maxYOffset: 2 });
+  });
+});

package/src/{getZeroedRangeOverlaps.ts → getZeroedRangeOverlaps.js}

@@ -1,4 +1,3 @@
-import { Range } from "./types";
 import getOverlapsOfPotentiallyCircularRanges from "./getOverlapsOfPotentiallyCircularRanges";
 import collapseOverlapsGeneratedFromRangeComparisonIfPossible from "./collapseOverlapsGeneratedFromRangeComparisonIfPossible";
 import zeroSubrangeByContainerRange from "./zeroSubrangeByContainerRange";
@@ -6,9 +5,9 @@ import normalizePositionByRangeLength from "./normalizePositionByRangeLength";
 
 //gets the overlapping sections of two ranges and zeroes them to their first point of intersection!
 export default function getZeroedRangeOverlaps(
-  annotation: Range,
-  selection: Range,
-  sequenceLength: number
+  annotation,
+  selection,
+  sequenceLength
 ) {
   const overlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible(
     getOverlapsOfPotentiallyCircularRanges(