@teselagen/range-utils 0.3.6 → 0.3.8

package/src/getAnnotationRangeType.test.js

@@ -1,59 +1,58 @@
-import getAnnotationRangeType from './getAnnotationRangeType';
-import chai from 'chai';
+import getAnnotationRangeType from "./getAnnotationRangeType";
+import chai from "chai";
 chai.should();
 
-describe('getAnnotationRangeType', function () {
-    it('should get the correct sub range type give a sub range and its enclosing range', function () {
-        getAnnotationRangeType(
-            {start: 4, end: 7}, 
-            {start: 4, end: 7}, 
-            true
-        ).should.equal('beginningAndEnd')
-        getAnnotationRangeType(
-            {start: 4, end: 7}, 
-            {start: 4, end: 7}, 
-            false
-        ).should.equal('beginningAndEnd')
-        getAnnotationRangeType(
-            {start: 4, end: 7}, 
-            {start: 4, end: 8}, 
-            true
-        ).should.equal('start')
-        getAnnotationRangeType(
-            {start: 4, end: 7}, 
-            {start: 4, end: 8}, 
-            false
-        ).should.equal('end')
-        getAnnotationRangeType(
-            {start: 4, end: 7}, 
-            {start: 3, end: 8}, 
-            true
-        ).should.equal('middle')
-        getAnnotationRangeType(
-            {start: 4, end: 7}, 
-            {start: 3, end: 8}, 
-            false
-        ).should.equal('middle')
-        getAnnotationRangeType(
-            {start: 4, end: 7}, 
-            {start: 3, end: 1}, 
-            true
-        ).should.equal('middle')
-        getAnnotationRangeType(
-            {start: 4, end: 7}, 
-            {start: 3, end: 2}, 
-            false
-        ).should.equal('middle')
-        getAnnotationRangeType(
-            {start: 4, end: 7}, 
-            {start: 4, end: 1}, 
-            true
-        ).should.equal('start')
-        getAnnotationRangeType(
-            {start: 4, end: 7}, 
-            {start: 9, end: 7}, 
-            false
-        ).should.equal('start')
-
-    });
-});
+describe("getAnnotationRangeType", function () {
+  it("should get the correct sub range type give a sub range and its enclosing range", function () {
+    getAnnotationRangeType(
+      { start: 4, end: 7 },
+      { start: 4, end: 7 },
+      true
+    ).should.equal("beginningAndEnd");
+    getAnnotationRangeType(
+      { start: 4, end: 7 },
+      { start: 4, end: 7 },
+      false
+    ).should.equal("beginningAndEnd");
+    getAnnotationRangeType(
+      { start: 4, end: 7 },
+      { start: 4, end: 8 },
+      true
+    ).should.equal("start");
+    getAnnotationRangeType(
+      { start: 4, end: 7 },
+      { start: 4, end: 8 },
+      false
+    ).should.equal("end");
+    getAnnotationRangeType(
+      { start: 4, end: 7 },
+      { start: 3, end: 8 },
+      true
+    ).should.equal("middle");
+    getAnnotationRangeType(
+      { start: 4, end: 7 },
+      { start: 3, end: 8 },
+      false
+    ).should.equal("middle");
+    getAnnotationRangeType(
+      { start: 4, end: 7 },
+      { start: 3, end: 1 },
+      true
+    ).should.equal("middle");
+    getAnnotationRangeType(
+      { start: 4, end: 7 },
+      { start: 3, end: 2 },
+      false
+    ).should.equal("middle");
+    getAnnotationRangeType(
+      { start: 4, end: 7 },
+      { start: 4, end: 1 },
+      true
+    ).should.equal("start");
+    getAnnotationRangeType(
+      { start: 4, end: 7 },
+      { start: 9, end: 7 },
+      false
+    ).should.equal("start");
+  });
+});

package/src/getEachPositionInRangeAsArray.js

@@ -1,15 +1,15 @@
-import normalizePositionByRangeLength from './normalizePositionByRangeLength';
-import getRangeLength from './getRangeLength';
+import normalizePositionByRangeLength from "./normalizePositionByRangeLength";
+import getRangeLength from "./getRangeLength";
 
 export default function getEachPositionInRangeAsArray(range, rangeMax) {
-    const output = [];
-    const length = getRangeLength(range, rangeMax);
-    if (!(length > 0)) {
-    	return output
-    }
-    for (let i = range.start; i < (length + range.start); i++) {
-        const position = normalizePositionByRangeLength(i, rangeMax);
-        output.push(position)
-    }    
-    return output
-};
+  const output = [];
+  const length = getRangeLength(range, rangeMax);
+  if (!(length > 0)) {
+    return output;
+  }
+  for (let i = range.start; i < length + range.start; i++) {
+    const position = normalizePositionByRangeLength(i, rangeMax);
+    output.push(position);
+  }
+  return output;
+}

package/src/getEachPositionInRangeAsArray.test.js

@@ -1,9 +1,13 @@
-import getEachPositionInRangeAsArray from './getEachPositionInRangeAsArray';
-import {expect} from 'chai';
+import getEachPositionInRangeAsArray from "./getEachPositionInRangeAsArray";
+import { expect } from "chai";
 
-describe('getEachPositionInRangeAsArray', function() {
-    it('should correctly determine whether a position is within a range', function() {
-        expect(getEachPositionInRangeAsArray({start: 1, end: 10}, 30)).to.deep.equal([1,2,3,4,5,6,7,8,9,10])
-        expect(getEachPositionInRangeAsArray({start: 10, end: 5}, 13)).to.deep.equal([10,11,12,0,1,2,3,4,5])
-    })
-})
+describe("getEachPositionInRangeAsArray", function () {
+  it("should correctly determine whether a position is within a range", function () {
+    expect(
+      getEachPositionInRangeAsArray({ start: 1, end: 10 }, 30)
+    ).to.deep.equal([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+    expect(
+      getEachPositionInRangeAsArray({ start: 10, end: 5 }, 13)
+    ).to.deep.equal([10, 11, 12, 0, 1, 2, 3, 4, 5]);
+  });
+});

package/src/getLengthOfOverlappingRegionsBetweenTwoRanges.js

@@ -1,9 +1,17 @@
-import getRangeLength from './getRangeLength';
-import getOverlapsOfPotentiallyCircularRanges from './getOverlapsOfPotentiallyCircularRanges';
+import getRangeLength from "./getRangeLength";
+import getOverlapsOfPotentiallyCircularRanges from "./getOverlapsOfPotentiallyCircularRanges";
 
-export default function getLengthOfOverlappingRegionsBetweenTwoRanges(rangeA, rangeB, maxLength) {
-    const overlaps = getOverlapsOfPotentiallyCircularRanges(rangeA,rangeB,maxLength);
-    return overlaps.reduce(function (counter, overlap) {
-        return counter + getRangeLength(overlap, maxLength)
-    }, 0)
-};
+export default function getLengthOfOverlappingRegionsBetweenTwoRanges(
+  rangeA,
+  rangeB,
+  maxLength
+) {
+  const overlaps = getOverlapsOfPotentiallyCircularRanges(
+    rangeA,
+    rangeB,
+    maxLength
+  );
+  return overlaps.reduce(function (counter, overlap) {
+    return counter + getRangeLength(overlap, maxLength);
+  }, 0);
+}

package/src/getLengthOfOverlappingRegionsBetweenTwoRanges.test.js

@@ -1,24 +1,32 @@
-import assert from 'assert';
-import getLengthOfOverlappingRegionsBetweenTwoRanges from './getLengthOfOverlappingRegionsBetweenTwoRanges';
-describe('getLengthOfOverlappingRegionsBetweenTwoRanges', function () {
-	it('should get the length of the overlaps in a simple case', function () {
-		const length = getLengthOfOverlappingRegionsBetweenTwoRanges({
-			start: 4,
-			end: 8
-		}, {
-			start: 5,
-			end: 10
-		}, 20);
-		assert.equal(length, 4)
-	});
-	it('should get the length of the overlaps', function () {
-		const length = getLengthOfOverlappingRegionsBetweenTwoRanges({
-			start: 4,
-			end: 8
-		}, {
-			start: 7,
-			end: 5
-		}, 20);
-		assert.equal(length, 4)
-	});
-});
+import assert from "assert";
+import getLengthOfOverlappingRegionsBetweenTwoRanges from "./getLengthOfOverlappingRegionsBetweenTwoRanges";
+describe("getLengthOfOverlappingRegionsBetweenTwoRanges", function () {
+  it("should get the length of the overlaps in a simple case", function () {
+    const length = getLengthOfOverlappingRegionsBetweenTwoRanges(
+      {
+        start: 4,
+        end: 8
+      },
+      {
+        start: 5,
+        end: 10
+      },
+      20
+    );
+    assert.equal(length, 4);
+  });
+  it("should get the length of the overlaps", function () {
+    const length = getLengthOfOverlappingRegionsBetweenTwoRanges(
+      {
+        start: 4,
+        end: 8
+      },
+      {
+        start: 7,
+        end: 5
+      },
+      20
+    );
+    assert.equal(length, 4);
+  });
+});

package/src/getMiddleOfRange.js

@@ -7,4 +7,4 @@ export default function getMiddleOfRange(range, rangeMax) {
     range.start + Math.floor(len / 2),
     rangeMax
   );
-};
+}

package/src/getMiddleOfRange.test.js

@@ -10,35 +10,27 @@
 import assert from "assert";
 
 import getMiddleOfRange from "./getMiddleOfRange";
-describe("getMiddleOfRange", function() {
-  it("should return the correct length for ranges that cross the origin", function() {
+describe("getMiddleOfRange", function () {
+  it("should return the correct length for ranges that cross the origin", function () {
     const midpoint = getMiddleOfRange({ start: 9, end: 0 }, 10);
-    console.log(`midpoint:`,midpoint)
     assert(midpoint === 0);
-
   });
-  it("should return the correct midpoint for ranges that do not cross the origin", function() {
+  it("should return the correct midpoint for ranges that do not cross the origin", function () {
     const midpoint = getMiddleOfRange({ start: 4, end: 6 }, 10);
-    console.log(`midpoint:`,midpoint)
     assert(midpoint === 5);
-
   });
-  it("should return the correct midpoint for ranges that overlapSelf", function() {
+  it("should return the correct midpoint for ranges that overlapSelf", function () {
     const midpoint = getMiddleOfRange(
       { start: 4, end: 9, overlapsSelf: true },
       10
     );
-    console.log(`midpoint:`,midpoint)
     assert(midpoint === 7);
-
   });
-  it("should return the correct midpoint for ranges that overlapSelf and origin", function() {
+  it("should return the correct midpoint for ranges that overlapSelf and origin", function () {
     const midpoint = getMiddleOfRange(
       { start: 9, end: 1, overlapsSelf: true },
       10
     );
-    console.log(`midpoint:`,midpoint)
     assert(midpoint === 0);
-
   });
 });

package/src/getOverlapOfNonCircularRanges.js

@@ -1,35 +1,35 @@
 export default function getOverlapOfNonCircularRanges(rangeA, rangeB) {
-    if (rangeA.start < rangeB.start) {
-        if (rangeA.end < rangeB.start) {
+  if (rangeA.start < rangeB.start) {
+    if (rangeA.end < rangeB.start) {
       //no overlap
-        } else {
-            if (rangeA.end < rangeB.end) {
-                return {
-                    start: rangeB.start,
-                    end: rangeA.end
-                };
-            } else {
-                return {
-                    start: rangeB.start,
-                    end: rangeB.end
-                };
-            }
-        }
     } else {
-        if (rangeA.start > rangeB.end) {
+      if (rangeA.end < rangeB.end) {
+        return {
+          start: rangeB.start,
+          end: rangeA.end
+        };
+      } else {
+        return {
+          start: rangeB.start,
+          end: rangeB.end
+        };
+      }
+    }
+  } else {
+    if (rangeA.start > rangeB.end) {
       //no overlap
-        } else {
-            if (rangeA.end < rangeB.end) {
-                return {
-                    start: rangeA.start,
-                    end: rangeA.end
-                };
-            } else {
-                return {
-                    start: rangeA.start,
-                    end: rangeB.end
-                };
-            }
-        }
+    } else {
+      if (rangeA.end < rangeB.end) {
+        return {
+          start: rangeA.start,
+          end: rangeA.end
+        };
+      } else {
+        return {
+          start: rangeA.start,
+          end: rangeB.end
+        };
+      }
     }
-};
+  }
+}

package/src/getOverlapsOfPotentiallyCircularRanges.js

@@ -1,4 +1,4 @@
-import {flatMap} from "lodash";
+import { flatMap } from "lodash";
 import splitRangeIntoTwoPartsIfItIsCircular from "./splitRangeIntoTwoPartsIfItIsCircular";
 import getOverlapOfNonCircularRanges from "./getOverlapOfNonCircularRanges";
 
@@ -20,8 +20,8 @@ export default function getOverlapsOfPotentiallyCircularRanges(
 
   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
@@ -39,7 +39,7 @@ export default function getOverlapsOfPotentiallyCircularRanges(
   ) {
     //we have 2 circular ranges that will have gotten split on the origin, so we'll manually mend those pieces back together
     const joinedOverlap = {};
-    overlaps = flatMap(overlaps, (o, i) => {
+    overlaps = flatMap(overlaps, o => {
       if (o.start === 0) {
         joinedOverlap.end = o.end;
         return [];
@@ -51,4 +51,4 @@ export default function getOverlapsOfPotentiallyCircularRanges(
     overlaps.push(joinedOverlap);
   }
   return overlaps;
-};
+}

package/src/getOverlapsOfPotentiallyCircularRanges.test.js

@@ -2,8 +2,8 @@ import getOverlapsOfPotentiallyCircularRanges from "./getOverlapsOfPotentiallyCi
 
 import assert from "assert";
 
-describe("getOverlapsOfPotentiallyCircularRanges", function() {
-  it("doesnt return an overlap for non overlapping ranges", function() {
+describe("getOverlapsOfPotentiallyCircularRanges", function () {
+  it("doesnt return an overlap for non overlapping ranges", function () {
     assert.deepEqual(
       getOverlapsOfPotentiallyCircularRanges(
         {
@@ -19,7 +19,7 @@ describe("getOverlapsOfPotentiallyCircularRanges", function() {
       []
     );
   });
-  it("does return overlaps for overlapping ranges", function() {
+  it("does return overlaps for overlapping ranges", function () {
     assert.deepEqual(
       getOverlapsOfPotentiallyCircularRanges(
         {
@@ -155,26 +155,6 @@ describe("getOverlapsOfPotentiallyCircularRanges", function() {
         }
       ]
     );
-    console.log(
-      `getOverlapsOfPotentiallyCircularRanges({
-            start: 5,
-            end: 3
-        }, {
-            start: 5,
-            end: 3
-        }, 10):`,
-      getOverlapsOfPotentiallyCircularRanges(
-        {
-          start: 5,
-          end: 3
-        },
-        {
-          start: 5,
-          end: 3
-        },
-        10
-      )
-    );
     assert.deepEqual(
       getOverlapsOfPotentiallyCircularRanges(
         {

package/src/getPositionFromAngle.js

@@ -1,7 +1,12 @@
-export default function getPositionFromAngle(angle, rangeMax, isInBetweenPositions) {
-    //percent through sequence * rangeMax
-    const unroundedPostion = angle / Math.PI / 2 * rangeMax
-    //return either the nearest position, or the nearest "inBetween" postion
-    return isInBetweenPositions ? Math.round(unroundedPostion) : Math.floor(unroundedPostion)
-};
-
+export default function getPositionFromAngle(
+  angle,
+  rangeMax,
+  isInBetweenPositions
+) {
+  //percent through sequence * rangeMax
+  const unroundedPostion = (angle / Math.PI / 2) * rangeMax;
+  //return either the nearest position, or the nearest "inBetween" postion
+  return isInBetweenPositions
+    ? Math.round(unroundedPostion)
+    : Math.floor(unroundedPostion);
+}

package/src/getRangeAngles.js

@@ -13,7 +13,7 @@ export default function getRangeAngles(range, rangeMax) {
     centerAngle: startAngle + totalAngle / 2,
     locationAngles:
       range.locations &&
-      range.locations.map((location) => {
+      range.locations.map(location => {
         return getRangeAngles(location, rangeMax);
       })
   };

package/src/getRangeAngles.test.js

@@ -9,24 +9,24 @@
 import getRangeAngles from "./getRangeAngles";
 
 import assert from "assert";
-describe("getRangeAngles", function() {
+describe("getRangeAngles", function () {
   //tnrtodo set this up
 
-  it("should return the correct angles for ranges that have joined locations", function() {
+  it("should return the correct angles for ranges that have joined locations", function () {
     const angles = getRangeAngles(
       {
         start: 1,
         end: 6,
         locations: [
           { start: 1, end: 2 },
-          { start: 3, end: 6 },
-        ],
+          { start: 3, end: 6 }
+        ]
       },
       10
     );
     // console.log('angles: ' + JSON.stringify(angles,null,4));
     const anglesInRadians = {};
-    Object.keys(angles).forEach(function(key) {
+    Object.keys(angles).forEach(function (key) {
       anglesInRadians[key] = (angles[key] * 360) / Math.PI / 2;
     });
 
@@ -37,7 +37,7 @@ describe("getRangeAngles", function() {
     angles.locationAngles &&
       angles.locationAngles.forEach((angles, i) => {
         const anglesInRadians = {};
-        Object.keys(angles).forEach(function(key) {
+        Object.keys(angles).forEach(function (key) {
           anglesInRadians[key] = (angles[key] * 360) / Math.PI / 2;
         });
         // console.log('anglesInRadians:',anglesInRadians)
@@ -47,13 +47,12 @@ describe("getRangeAngles", function() {
         assert((anglesInRadians.endAngle === i) === 0 ? 108 : 252);
         assert((anglesInRadians.totalAngle === i) === 0 ? 72 : 144);
       });
-
   });
-  it("should return the correct angles for ranges that cross the origin", function() {
+  it("should return the correct angles for ranges that cross the origin", function () {
     const angles = getRangeAngles({ start: 9, end: 0 }, 10);
     // console.log('angles: ' + JSON.stringify(angles,null,4));
     const anglesInRadians = {};
-    Object.keys(angles).forEach(function(key) {
+    Object.keys(angles).forEach(function (key) {
       anglesInRadians[key] = (angles[key] * 360) / Math.PI / 2;
     });
     assert(anglesInRadians.startAngle === 324);
@@ -61,11 +60,11 @@ describe("getRangeAngles", function() {
     assert(anglesInRadians.totalAngle === 72);
     // console.log('anglesInRadians: ' + JSON.stringify(anglesInRadians,null,4));
   });
-  it("should return the correct angles for ranges that do not cross the origin", function() {
+  it("should return the correct angles for ranges that do not cross the origin", function () {
     const angles = getRangeAngles({ start: 1, end: 2, overlapsSelf: true }, 10);
     // console.log('angles: ' + JSON.stringify(angles,null,4));
     const anglesInRadians = {};
-    Object.keys(angles).forEach(function(key) {
+    Object.keys(angles).forEach(function (key) {
       anglesInRadians[key] = (angles[key] * 360) / Math.PI / 2;
     });
     // console.log('anglesInRadians: ' + JSON.stringify(anglesInRadians,null,4));

package/src/getRangeLength.test.js

@@ -10,20 +10,20 @@
 import assert from "assert";
 
 import getRangeLength from "./getRangeLength";
-describe("getRangeLength", function() {
-  it("should return the correct length for ranges that cross the origin", function() {
+describe("getRangeLength", function () {
+  it("should return the correct length for ranges that cross the origin", function () {
     const length = getRangeLength({ start: 9, end: 0 }, 10);
     assert(length === 2);
   });
-  it("should return the correct length for ranges that do not cross the origin", function() {
+  it("should return the correct length for ranges that do not cross the origin", function () {
     const length = getRangeLength({ start: 4, end: 6 }, 10);
     assert(length === 3);
   });
-  it("should return the correct length for ranges that overlapSelf", function() {
+  it("should return the correct length for ranges that overlapSelf", function () {
     const length = getRangeLength({ start: 4, end: 6, overlapsSelf: true }, 10);
     assert(length === 13);
   });
-  it("should return the correct length for ranges that overlapSelf and origin", function() {
+  it("should return the correct length for ranges that overlapSelf and origin", function () {
     const length = getRangeLength({ start: 9, end: 1, overlapsSelf: true }, 10);
     assert(length === 13);
   });

package/src/getRangesBetweenTwoRanges.js

@@ -1,28 +1,37 @@
 export default function getRangesBetweenTwoRanges(range1, range2) {
-    // {
-    //     start: 85,
-    //     end: 92
-    // }
+  // {
+  //     start: 85,
+  //     end: 92
+  // }
 
-    // {
-    //     start: 130,
-    //     end: 189
-    // }
+  // {
+  //     start: 130,
+  //     end: 189
+  // }
 
-    // start1 - end2
+  // start1 - end2
 
-    // start2 - end1
+  // start2 - end1
 
-    const newRanges = [];	
-    if (!(range1.start > -1 && range1.end > -1 && range2.start > -1 && range2.end > -1)) {
-        return newRanges
+  const newRanges = [];
+  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,
-    }]    
-};
-
+  ];
+}