@teselagen/range-utils 0.3.7 → 0.3.9

package/src/getSequenceWithinRange.js

@@ -1,17 +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;
+  // 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 {
-        return sequence.slice(range.start, range.end + 1);
+      subSequence = subSequence.concat(sequence.slice(0, range.end + 1));
     }
-};
+    return subSequence;
+  } else {
+    return sequence.slice(range.start, range.end + 1);
+  }
+}

package/src/getSequenceWithinRange.test.js

@@ -1,49 +1,47 @@
+import getSequenceWithinRange from "./getSequenceWithinRange.js";
 
-
-import getSequenceWithinRange from './getSequenceWithinRange.js';
-
-import assert from 'assert';
+import assert from "assert";
 let subseq;
 
-describe('getSequenceWithinRange', function() {
-    it('works with an array (translation amino acids for example) as well', function() {
-        subseq = getSequenceWithinRange({start: 0,end:0},['a','t','g','c']);
-        assert.deepEqual(subseq, ['a']);
-        subseq = getSequenceWithinRange({start: 1,end:1},['a','t','g','c']);
-        assert.deepEqual(subseq, ['t']);
-        subseq = getSequenceWithinRange({start: 1,end:0},['a','t','g','c']);
-        assert.deepEqual(subseq, ['t','g','c','a']);
-    });
-    it('gets a non circular range', function() {
-        subseq = getSequenceWithinRange({start: 0,end:0},'atgc');
-        assert.equal(subseq, 'a');
-        subseq = getSequenceWithinRange({start: 1,end:1},'atgc');
-        assert.equal(subseq, 't');
-        subseq = getSequenceWithinRange({start: 0,end:3},'atgc');
-        assert.equal(subseq, 'atgc');
-    });
-    it('gets a circular range', function() {
-        subseq = getSequenceWithinRange({start: 1,end:0},'atgc');
-        assert.deepEqual(subseq, 'tgca');
-        subseq = getSequenceWithinRange({start: 2,end:1},'atgc');
-        assert.deepEqual(subseq, 'gcat');
-        subseq = getSequenceWithinRange({start: 3,end:0},'atgc');
-        assert.deepEqual(subseq, 'ca');
-    });
-    it('gets a circular range', function() {
-        subseq = getSequenceWithinRange({start: 1,end:0},'atgc');
-        assert.deepEqual(subseq, 'tgca');
-        subseq = getSequenceWithinRange({start: 2,end:1},'atgc');
-        assert.deepEqual(subseq, 'gcat');
-        subseq = getSequenceWithinRange({start: 3,end:0},'atgc');
-        assert.deepEqual(subseq, 'ca');
-    });
-    it('returns an empty string if the range is invalid', function() {
-        subseq = getSequenceWithinRange({start: -1,end:0},'atgc');
-        assert.deepEqual(subseq, '');
-        subseq = getSequenceWithinRange({start: -1,end:-1},'atgc');
-        assert.deepEqual(subseq, '');
-        subseq = getSequenceWithinRange({start: 3,end:-1},'atgc');
-        assert.deepEqual(subseq, '');
-    });
+describe("getSequenceWithinRange", function () {
+  it("works with an array (translation amino acids for example) as well", function () {
+    subseq = getSequenceWithinRange({ start: 0, end: 0 }, ["a", "t", "g", "c"]);
+    assert.deepEqual(subseq, ["a"]);
+    subseq = getSequenceWithinRange({ start: 1, end: 1 }, ["a", "t", "g", "c"]);
+    assert.deepEqual(subseq, ["t"]);
+    subseq = getSequenceWithinRange({ start: 1, end: 0 }, ["a", "t", "g", "c"]);
+    assert.deepEqual(subseq, ["t", "g", "c", "a"]);
+  });
+  it("gets a non circular range", function () {
+    subseq = getSequenceWithinRange({ start: 0, end: 0 }, "atgc");
+    assert.equal(subseq, "a");
+    subseq = getSequenceWithinRange({ start: 1, end: 1 }, "atgc");
+    assert.equal(subseq, "t");
+    subseq = getSequenceWithinRange({ start: 0, end: 3 }, "atgc");
+    assert.equal(subseq, "atgc");
+  });
+  it("gets a circular range", function () {
+    subseq = getSequenceWithinRange({ start: 1, end: 0 }, "atgc");
+    assert.deepEqual(subseq, "tgca");
+    subseq = getSequenceWithinRange({ start: 2, end: 1 }, "atgc");
+    assert.deepEqual(subseq, "gcat");
+    subseq = getSequenceWithinRange({ start: 3, end: 0 }, "atgc");
+    assert.deepEqual(subseq, "ca");
+  });
+  it("gets a circular range", function () {
+    subseq = getSequenceWithinRange({ start: 1, end: 0 }, "atgc");
+    assert.deepEqual(subseq, "tgca");
+    subseq = getSequenceWithinRange({ start: 2, end: 1 }, "atgc");
+    assert.deepEqual(subseq, "gcat");
+    subseq = getSequenceWithinRange({ start: 3, end: 0 }, "atgc");
+    assert.deepEqual(subseq, "ca");
+  });
+  it("returns an empty string if the range is invalid", function () {
+    subseq = getSequenceWithinRange({ start: -1, end: 0 }, "atgc");
+    assert.deepEqual(subseq, "");
+    subseq = getSequenceWithinRange({ start: -1, end: -1 }, "atgc");
+    assert.deepEqual(subseq, "");
+    subseq = getSequenceWithinRange({ start: 3, end: -1 }, "atgc");
+    assert.deepEqual(subseq, "");
+  });
 });

package/src/getShortestDistanceBetweenTwoPositions.js

@@ -1,12 +1,16 @@
-export default function getShortestDistanceBetweenTwoPositions(position1, position2, sequenceLength) {
+export default function getShortestDistanceBetweenTwoPositions(
+  position1,
+  position2,
+  sequenceLength
+) {
   if (position1 < position2) {
-	const position1Holder = position1;
-  	position1 = position2
-	position2 = position1Holder
+    const position1Holder = position1;
+    position1 = position2;
+    position2 = position1Holder;
   }
   //position 1 is now always >= position 2
 
   const d1 = position1 - position2;
   const d2 = sequenceLength - position1 + position2;
-  return Math.min(d1,d2)
-};
+  return Math.min(d1, d2);
+}

package/src/getShortestDistanceBetweenTwoPositions.test.js

@@ -1,14 +1,12 @@
-import assert from 'assert';
-import getShortestDistanceBetweenTwoPositions from './getShortestDistanceBetweenTwoPositions';
-describe('getShortestDistanceBetweenTwoPositions', function () {
-	it('should return the correct length for positions that cross the origin', function () {
-		const length = getShortestDistanceBetweenTwoPositions(9,0,10);
-		assert(length === 1)
-
-	});
-	it('should return the correct length for ranges that do not cross the origin', function () {
-		const length = getShortestDistanceBetweenTwoPositions(4,6,10);
-		assert(length === 2)
-
-	});
+import assert from "assert";
+import getShortestDistanceBetweenTwoPositions from "./getShortestDistanceBetweenTwoPositions";
+describe("getShortestDistanceBetweenTwoPositions", function () {
+  it("should return the correct length for positions that cross the origin", function () {
+    const length = getShortestDistanceBetweenTwoPositions(9, 0, 10);
+    assert(length === 1);
+  });
+  it("should return the correct length for ranges that do not cross the origin", function () {
+    const length = getShortestDistanceBetweenTwoPositions(4, 6, 10);
+    assert(length === 2);
+  });
 });

package/src/getYOffsetForPotentiallyCircularRange.js

@@ -1,24 +1,36 @@
-import checkIfPotentiallyCircularRangesOverlap from './checkIfPotentiallyCircularRangesOverlap';
+import checkIfPotentiallyCircularRangesOverlap from "./checkIfPotentiallyCircularRangesOverlap";
 
-export default function getYOffsetForPotentiallyCircularRange(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 = [];
-    //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(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
+export default function getYOffsetForPotentiallyCircularRange(
+  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 = [];
+  //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(
+    function (rangesAlreadyAddedToYOffset, index) {
+      const rangeBlocked = rangesAlreadyAddedToYOffset.some(
+        function (comparisonRange) {
+          return checkIfPotentiallyCircularRangesOverlap(
+            range,
+            comparisonRange
+          );
         }
-    });
-    if (!openYOffsetFound) {
-        yOffset = YOffsetLevelsWithRanges.length
-        if (assignYOffsetToRange) range.yOffset = YOffsetLevelsWithRanges.length
+      );
+      if (!rangeBlocked) {
+        yOffset = index;
+        if (assignYOffsetToRange) range.yOffset = index;
+        rangesAlreadyAddedToYOffset.push(range);
+        return true;
+      }
+      return false;
     }
-    return yOffset
-};
+  );
+  if (!openYOffsetFound) {
+    yOffset = YOffsetLevelsWithRanges.length;
+    if (assignYOffsetToRange) range.yOffset = YOffsetLevelsWithRanges.length;
+  }
+  return yOffset;
+}

package/src/getYOffsetsForPotentiallyCircularRanges.js

@@ -1,20 +1,27 @@
-import getYOffsetForPotentiallyCircularRange from './getYOffsetForPotentiallyCircularRange';
+import getYOffsetForPotentiallyCircularRange from "./getYOffsetForPotentiallyCircularRange";
 
-export default function getYOffsetsForPotentiallyCircularRanges(ranges, assignYOffsetToRange) {
-    //adjust the yOffset of the range being pushed in by checking its range against other ranges already in the row
-    const yOffsets = [];
-    let maxYOffset = 0;
-    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(range, yOffsetLevels, assignYOffsetToRange)
-        yOffsets.push(yOffset)
-        if (yOffset>maxYOffset) {
-            maxYOffset = yOffset;
-        }
-        range.yOffset = yOffset;
-        if (!yOffsetLevels[yOffset]) yOffsetLevels[yOffset] = [];
-        yOffsetLevels[yOffset].push(range);
-    });
-    return {yOffsets:yOffsets, maxYOffset: maxYOffset};
-};
+export default function getYOffsetsForPotentiallyCircularRanges(
+  ranges,
+  assignYOffsetToRange
+) {
+  //adjust the yOffset of the range being pushed in by checking its range against other ranges already in the row
+  const yOffsets = [];
+  let maxYOffset = 0;
+  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(
+      range,
+      yOffsetLevels,
+      assignYOffsetToRange
+    );
+    yOffsets.push(yOffset);
+    if (yOffset > maxYOffset) {
+      maxYOffset = yOffset;
+    }
+    range.yOffset = yOffset;
+    if (!yOffsetLevels[yOffset]) yOffsetLevels[yOffset] = [];
+    yOffsetLevels[yOffset].push(range);
+  });
+  return { yOffsets: yOffsets, maxYOffset: maxYOffset };
+}

package/src/getYOffsetsForPotentiallyCircularRanges.test.js

@@ -1,29 +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});
-    });
-});
+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.js

@@ -1,17 +1,32 @@
-
-import getOverlapsOfPotentiallyCircularRanges from './getOverlapsOfPotentiallyCircularRanges';
-import collapseOverlapsGeneratedFromRangeComparisonIfPossible from './collapseOverlapsGeneratedFromRangeComparisonIfPossible';
-import zeroSubrangeByContainerRange from './zeroSubrangeByContainerRange';
-import normalizePositionByRangeLength from './normalizePositionByRangeLength';
+import getOverlapsOfPotentiallyCircularRanges from "./getOverlapsOfPotentiallyCircularRanges";
+import collapseOverlapsGeneratedFromRangeComparisonIfPossible from "./collapseOverlapsGeneratedFromRangeComparisonIfPossible";
+import zeroSubrangeByContainerRange from "./zeroSubrangeByContainerRange";
+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, selection, sequenceLength)  {
-  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 zeroedOverlaps
-};
+export default function getZeroedRangeOverlaps(
+  annotation,
+  selection,
+  sequenceLength
+) {
+  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 zeroedOverlaps;
+}

package/src/getZeroedRangeOverlaps.test.js

@@ -1,36 +1,75 @@
-import assert from 'assert';
-import getZeroedRangeOverlaps from './getZeroedRangeOverlaps';
-describe('getZeroedRangeOverlaps', function() {
-    it('annotation non-circular, selection non circular ', function() {
-        const res = getZeroedRangeOverlaps({start: 0, end: 3}, {start: 2, end: 3}, 4, true, true) 
-        assert.deepEqual(res, [{start: 0, end:1}])
-    })
-    it('annotation non circular, selection circular', function() {
-      //01234
-      //aaaa 
-      //s sss
-        const res = getZeroedRangeOverlaps({start: 0, end: 3}, {start: 2, end: 0}, 5, true, true) 
-        assert.deepEqual(res, [ {start: 3,end: 3}, {start: 0, end:1}])
-    })
-    it('annotation non circular, selection circular 2', function() {
-      //0123
-      //aaaa
-      //ssss 
-        const res = getZeroedRangeOverlaps({start: 0, end: 3}, {start: 2, end: 1}, 4, true, true) 
-        assert.deepEqual(res, [ {start: 2,end: 3}, {start: 0, end:1},])
-    })
-    it('annotation circular, selection fully containing', function() {
-      //01234
-      //aa aa
-      //sssss 
-        const res = getZeroedRangeOverlaps({start: 3, end: 1}, {start: 0, end: 4}, 5, true, true) 
-        assert.deepEqual(res, [{start: 3, end: 1}])
-    })
-    it('annotation circular, selection fully containing 2', function() {
-      //01234
-      //aa aa
-      //sssss 
-        const res = getZeroedRangeOverlaps({start: 3, end: 1}, {start: 1, end: 0}, 5, true, true) 
-        assert.deepEqual(res, [{start: 2, end: 4}, {start: 0, end: 0}])
-    })
-})
+import assert from "assert";
+import getZeroedRangeOverlaps from "./getZeroedRangeOverlaps";
+describe("getZeroedRangeOverlaps", function () {
+  it("annotation non-circular, selection non circular ", function () {
+    const res = getZeroedRangeOverlaps(
+      { start: 0, end: 3 },
+      { start: 2, end: 3 },
+      4,
+      true,
+      true
+    );
+    assert.deepEqual(res, [{ start: 0, end: 1 }]);
+  });
+  it("annotation non circular, selection circular", function () {
+    //01234
+    //aaaa
+    //s sss
+    const res = getZeroedRangeOverlaps(
+      { start: 0, end: 3 },
+      { start: 2, end: 0 },
+      5,
+      true,
+      true
+    );
+    assert.deepEqual(res, [
+      { start: 3, end: 3 },
+      { start: 0, end: 1 }
+    ]);
+  });
+  it("annotation non circular, selection circular 2", function () {
+    //0123
+    //aaaa
+    //ssss
+    const res = getZeroedRangeOverlaps(
+      { start: 0, end: 3 },
+      { start: 2, end: 1 },
+      4,
+      true,
+      true
+    );
+    assert.deepEqual(res, [
+      { start: 2, end: 3 },
+      { start: 0, end: 1 }
+    ]);
+  });
+  it("annotation circular, selection fully containing", function () {
+    //01234
+    //aa aa
+    //sssss
+    const res = getZeroedRangeOverlaps(
+      { start: 3, end: 1 },
+      { start: 0, end: 4 },
+      5,
+      true,
+      true
+    );
+    assert.deepEqual(res, [{ start: 3, end: 1 }]);
+  });
+  it("annotation circular, selection fully containing 2", function () {
+    //01234
+    //aa aa
+    //sssss
+    const res = getZeroedRangeOverlaps(
+      { start: 3, end: 1 },
+      { start: 1, end: 0 },
+      5,
+      true,
+      true
+    );
+    assert.deepEqual(res, [
+      { start: 2, end: 4 },
+      { start: 0, end: 0 }
+    ]);
+  });
+});