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

package/src/adjustRangeToRotation.ts

@@ -0,0 +1,22 @@
+import { assign } from "lodash-es";
+
+import { Range } from "./types";
+
+export default function adjustRangeToRotation<T extends Range>(
+  rangeToBeAdjusted: T,
+  rotateTo = 0,
+  rangeLength?: number
+): T {
+  const mod = (n: number) => (rangeLength ? modulo(n, rangeLength) : n);
+
+  const newRange = assign({}, rangeToBeAdjusted, {
+    start: mod(rangeToBeAdjusted.start - (rotateTo || 0)),
+    end: mod(rangeToBeAdjusted.end - (rotateTo || 0))
+  });
+
+  return newRange as T;
+}
+
+function modulo(n: number, m: number) {
+  return ((n % m) + m) % m;
+}

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

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

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

@@ -1,14 +1,14 @@
 //
+//
 import checkIfNonCircularRangesOverlap from "./checkIfNonCircularRangesOverlap";
 
 import splitRangeIntoTwoPartsIfItIsCircular from "./splitRangeIntoTwoPartsIfItIsCircular";
-// ac.throw([ac.posInt, ac.posInt, ac.bool], arguments);
+import { Range } from "./types";
 
 export default function checkIfPotentiallyCircularRangesOverlap(
-  range,
-  comparisonRange
+  range: Range,
+  comparisonRange: Range
 ) {
-  // 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.js → collapseOverlapsGeneratedFromRangeComparisonIfPossible.ts}

@@ -1,10 +1,12 @@
+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,
-  sequenceLength,
-  optionalOriginalRange
-) {
+  overlaps: Range[],
+  sequenceLength: number,
+  optionalOriginalRange?: Range
+): Range[] {
   const originalRangeLinear =
     optionalOriginalRange &&
     optionalOriginalRange.start <= optionalOriginalRange.end;
@@ -75,4 +77,5 @@ export default function collapseOverlapsGeneratedFromRangeComparisonIfPossible(
       }
     }
   }
+  return overlaps;
 }

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

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

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

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

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

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

package/src/doesRangeSpanEntireSequence.ts

@@ -0,0 +1,12 @@
+import getRangeLength from "./getRangeLength";
+import { Range } from "./types";
+
+export default function doesRangeSpanEntireSequence(
+  range: Range,
+  sequenceLength: number
+) {
+  if (getRangeLength(range, sequenceLength) === sequenceLength) {
+    return true;
+  }
+  return false;
+}

package/src/doesRangeSpanOrigin.ts

@@ -0,0 +1,5 @@
+import { Range } from "./types";
+
+export default function doesRangeSpanOrigin(range: Range) {
+  return range.start > range.end;
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -2,12 +2,15 @@ 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,
-  rangeB,
-  maxRangeLength,
-  joinIfPossible //by default this fn only returns **non-circular** overlaps, if true it will try to join overlaps split on the origin
+  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
 ) {
   const normalizedRangeA = splitRangeIntoTwoPartsIfItIsCircular(
     rangeA,
@@ -18,7 +21,7 @@ export default function getOverlapsOfPotentiallyCircularRanges(
     maxRangeLength
   );
 
-  let overlaps = [];
+  let overlaps: Range[] = [];
 
   normalizedRangeA.forEach(function (nonCircularRangeA) {
     normalizedRangeB.forEach(function (nonCircularRangeB) {
@@ -38,7 +41,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 = {};
+    const joinedOverlap: Partial<Range> = {};
     overlaps = flatMap(overlaps, o => {
       if (o.start === 0) {
         joinedOverlap.end = o.end;
@@ -47,8 +50,11 @@ export default function getOverlapsOfPotentiallyCircularRanges(
         joinedOverlap.start = o.start;
         return [];
       }
+      return [o];
     });
-    overlaps.push(joinedOverlap);
+    if (Object.keys(joinedOverlap).length > 0) {
+      overlaps.push(joinedOverlap as Range);
+    }
   }
   return overlaps;
 }

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

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

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

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

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

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

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

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

package/src/getSequenceWithinRange.ts

@@ -0,0 +1,33 @@
+import { Range } from "./types";
+
+// overload the function signatures so that TS knows what type to expect back (string or T[])
+export default function getSequenceWithinRange(
+  range: Range,
+  sequence: string
+): string;
+export default function getSequenceWithinRange<T>(
+  range: Range,
+  sequence: T[]
+): T[];
+export default function getSequenceWithinRange<T>(
+  range: Range,
+  sequence: string | T[]
+) {
+  if (range.start < 0 || range.end < 0) {
+    if (typeof sequence === "string") return "";
+    return [];
+  }
+  if (range.start > range.end) {
+    //circular range
+    const subSequence = sequence.slice(range.start, sequence.length);
+    if (typeof subSequence === "string") {
+      return subSequence + sequence.slice(0, range.end + 1);
+    } else {
+      return (subSequence as T[]).concat(
+        sequence.slice(0, range.end + 1) as T[]
+      );
+    }
+  } else {
+    return sequence.slice(range.start, range.end + 1);
+  }
+}

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

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

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

@@ -1,12 +1,13 @@
 import checkIfPotentiallyCircularRangesOverlap from "./checkIfPotentiallyCircularRangesOverlap";
+import { Range } from "./types";
 
 export default function getYOffsetForPotentiallyCircularRange(
-  range,
-  YOffsetLevelsWithRanges,
-  assignYOffsetToRange
+  range: Range,
+  YOffsetLevelsWithRanges: Range[][],
+  assignYOffsetToRange: boolean
 ) {
   //adjust the yOffset of the range being pushed in by checking its range against other range already in the row
-  let yOffset = [];
+  let yOffset = 0;
   //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.test.ts

@@ -0,0 +1,17 @@
+import { expect } from "chai";
+import getYOffsetsForPotentiallyCircularRanges from "./getYOffsetsForPotentiallyCircularRanges.js";
+describe("getYOffsetsForPotentiallyCircularRanges", function () {
+  it("returns correct yOffset for overlapping ranges", function () {
+    const ranges = [
+      { start: 0, end: 10, id: "1" },
+      { start: 5, end: 20, id: "2" },
+      { start: 15, end: 25, id: "3" }
+    ];
+    getYOffsetsForPotentiallyCircularRanges(ranges, false);
+    expect(ranges).to.deep.equal([
+      { start: 0, end: 10, id: "1", yOffset: 0 },
+      { start: 5, end: 20, id: "2", yOffset: 1 },
+      { start: 15, end: 25, id: "3", yOffset: 0 }
+    ]);
+  });
+});

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

@@ -1,13 +1,14 @@
 import getYOffsetForPotentiallyCircularRange from "./getYOffsetForPotentiallyCircularRange";
+import { Range } from "./types";
 
 export default function getYOffsetsForPotentiallyCircularRanges(
-  ranges,
-  assignYOffsetToRange
+  ranges: Range[],
+  assignYOffsetToRange: boolean
 ) {
   //adjust the yOffset of the range being pushed in by checking its range against other ranges already in the row
-  const yOffsets = [];
+  const yOffsets: number[] = [];
   let maxYOffset = 0;
-  const yOffsetLevels = []; //yOffsetLevels is an array of arrays (array of yOffset levels holding arrays of ranges)
+  const yOffsetLevels: Range[][] = []; //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/{getZeroedRangeOverlaps.test.js → getZeroedRangeOverlaps.test.ts}

@@ -5,9 +5,7 @@ describe("getZeroedRangeOverlaps", function () {
     const res = getZeroedRangeOverlaps(
       { start: 0, end: 3 },
       { start: 2, end: 3 },
-      4,
-      true,
-      true
+      4
     );
     assert.deepEqual(res, [{ start: 0, end: 1 }]);
   });
@@ -18,9 +16,7 @@ describe("getZeroedRangeOverlaps", function () {
     const res = getZeroedRangeOverlaps(
       { start: 0, end: 3 },
       { start: 2, end: 0 },
-      5,
-      true,
-      true
+      5
     );
     assert.deepEqual(res, [
       { start: 3, end: 3 },
@@ -34,9 +30,7 @@ describe("getZeroedRangeOverlaps", function () {
     const res = getZeroedRangeOverlaps(
       { start: 0, end: 3 },
       { start: 2, end: 1 },
-      4,
-      true,
-      true
+      4
     );
     assert.deepEqual(res, [
       { start: 2, end: 3 },
@@ -50,9 +44,7 @@ describe("getZeroedRangeOverlaps", function () {
     const res = getZeroedRangeOverlaps(
       { start: 3, end: 1 },
       { start: 0, end: 4 },
-      5,
-      true,
-      true
+      5
     );
     assert.deepEqual(res, [{ start: 3, end: 1 }]);
   });
@@ -63,9 +55,7 @@ describe("getZeroedRangeOverlaps", function () {
     const res = getZeroedRangeOverlaps(
       { start: 3, end: 1 },
       { start: 1, end: 0 },
-      5,
-      true,
-      true
+      5
     );
     assert.deepEqual(res, [
       { start: 2, end: 4 },