@teselagen/range-utils 0.3.7 → 0.3.8

package/src/checkIfPotentiallyCircularRangesOverlap.test.js

@@ -1,73 +1,118 @@
-import {expect} from 'chai';
+import { expect } from "chai";
 
-import checkIfPotentiallyCircularRangesOverlap from './checkIfPotentiallyCircularRangesOverlap.js';
+import checkIfPotentiallyCircularRangesOverlap from "./checkIfPotentiallyCircularRangesOverlap.js";
 // checkIfPotentiallyCircularRangesOverlap(frame, sequence, minimumOrfSize, forward, circular)
-describe('checkIfPotentiallyCircularRangesOverlap', function() {
-    it('returns true if ranges do overlap', function() {
-        expect(checkIfPotentiallyCircularRangesOverlap({
-            start: 5,
-            end: 100
-        }, {
-            start: 50,
-            end: 50
-        })).to.equal(true);
-        expect(checkIfPotentiallyCircularRangesOverlap({
-            start: 5,
-            end: 100
-        }, {
-            start: 50,
-            end: 500
-        })).to.equal(true);
-        expect(checkIfPotentiallyCircularRangesOverlap({
-            start: 5,
-            end: 100
-        }, {
-            start: 0,
-            end: 5
-        })).to.equal(true);
-        expect(checkIfPotentiallyCircularRangesOverlap({
-            start: 50,
-            end: 10
-        }, {
-            start: 0,
-            end: 5
-        })).to.equal(true);
-        expect(checkIfPotentiallyCircularRangesOverlap({
-            start: 50,
-            end: 10
-        }, {
-            start: 20,
-            end: 5
-        })).to.equal(true);
-        expect(checkIfPotentiallyCircularRangesOverlap({
-            start: 50,
-            end: 10
-        }, {
-            start: 20,
-            end: 51
-        })).to.equal(true);
-    });
-    it('returns false if ranges do not overlap', function() {
-        expect(checkIfPotentiallyCircularRangesOverlap({
-            start: 5,
-            end: 100
-        }, {
-            start: 1,
-            end: 4
-        })).to.equal(false);
-        expect(checkIfPotentiallyCircularRangesOverlap({
-            start: 50,
-            end: 10
-        }, {
-            start: 20,
-            end: 49
-        })).to.equal(false);
-        expect(checkIfPotentiallyCircularRangesOverlap({
-            start: 5,
-            end: 100
-        }, {
-            start: 101,
-            end: 101
-        })).to.equal(false);
-    });
+describe("checkIfPotentiallyCircularRangesOverlap", function () {
+  it("returns true if ranges do overlap", function () {
+    expect(
+      checkIfPotentiallyCircularRangesOverlap(
+        {
+          start: 5,
+          end: 100
+        },
+        {
+          start: 50,
+          end: 50
+        }
+      )
+    ).to.equal(true);
+    expect(
+      checkIfPotentiallyCircularRangesOverlap(
+        {
+          start: 5,
+          end: 100
+        },
+        {
+          start: 50,
+          end: 500
+        }
+      )
+    ).to.equal(true);
+    expect(
+      checkIfPotentiallyCircularRangesOverlap(
+        {
+          start: 5,
+          end: 100
+        },
+        {
+          start: 0,
+          end: 5
+        }
+      )
+    ).to.equal(true);
+    expect(
+      checkIfPotentiallyCircularRangesOverlap(
+        {
+          start: 50,
+          end: 10
+        },
+        {
+          start: 0,
+          end: 5
+        }
+      )
+    ).to.equal(true);
+    expect(
+      checkIfPotentiallyCircularRangesOverlap(
+        {
+          start: 50,
+          end: 10
+        },
+        {
+          start: 20,
+          end: 5
+        }
+      )
+    ).to.equal(true);
+    expect(
+      checkIfPotentiallyCircularRangesOverlap(
+        {
+          start: 50,
+          end: 10
+        },
+        {
+          start: 20,
+          end: 51
+        }
+      )
+    ).to.equal(true);
+  });
+  it("returns false if ranges do not overlap", function () {
+    expect(
+      checkIfPotentiallyCircularRangesOverlap(
+        {
+          start: 5,
+          end: 100
+        },
+        {
+          start: 1,
+          end: 4
+        }
+      )
+    ).to.equal(false);
+    expect(
+      checkIfPotentiallyCircularRangesOverlap(
+        {
+          start: 50,
+          end: 10
+        },
+        {
+          start: 20,
+          end: 49
+        }
+      )
+    ).to.equal(false);
+    expect(
+      checkIfPotentiallyCircularRangesOverlap(
+        {
+          start: 5,
+          end: 100
+        },
+        {
+          start: 101,
+          end: 101
+        }
+      )
+    ).to.equal(false);
+  });
 });

package/src/collapseOverlapsGeneratedFromRangeComparisonIfPossible.js

@@ -1,47 +1,78 @@
-
-
-//this function is a little confusing, but basically it takes an array of overlaps 
+//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) {
-    const originalRangeLinear = optionalOriginalRange && (optionalOriginalRange.start <= optionalOriginalRange.end)
-    if (overlaps.length === 1 || overlaps.length === 0) {
-        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
-            }];
-        } else if (overlaps[1].start === 0 && overlaps[0].end + 1 === sequenceLength && !originalRangeLinear) {
-            return [{
-                start: overlaps[0].start,
-                end: overlaps[1].end
-            }];
-        } else {
-            return overlaps;
+export default function collapseOverlapsGeneratedFromRangeComparisonIfPossible(
+  overlaps,
+  sequenceLength,
+  optionalOriginalRange
+) {
+  const originalRangeLinear =
+    optionalOriginalRange &&
+    optionalOriginalRange.start <= optionalOriginalRange.end;
+  if (overlaps.length === 1 || overlaps.length === 0) {
+    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
+        }
+      ];
+    } else if (
+      overlaps[1].start === 0 &&
+      overlaps[0].end + 1 === sequenceLength &&
+      !originalRangeLinear
+    ) {
+      return [
+        {
+          start: overlaps[0].start,
+          end: overlaps[1].end
         }
-    } else if (overlaps.length === 3) {
-        const firstOverlap = overlaps[0];
-        const secondOverlap = overlaps[1];
-        const thirdOverlap = overlaps[2];
-        let collapsedOverlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible([firstOverlap, secondOverlap], sequenceLength, optionalOriginalRange);
+      ];
+    } else {
+      return overlaps;
+    }
+  } else if (overlaps.length === 3) {
+    const firstOverlap = overlaps[0];
+    const secondOverlap = overlaps[1];
+    const thirdOverlap = overlaps[2];
+    let collapsedOverlaps =
+      collapseOverlapsGeneratedFromRangeComparisonIfPossible(
+        [firstOverlap, secondOverlap],
+        sequenceLength,
+        optionalOriginalRange
+      );
+    if (collapsedOverlaps.length === 1) {
+      collapsedOverlaps.push(thirdOverlap);
+      return collapsedOverlaps;
+    } else {
+      collapsedOverlaps =
+        collapseOverlapsGeneratedFromRangeComparisonIfPossible(
+          [firstOverlap, thirdOverlap],
+          sequenceLength,
+          optionalOriginalRange
+        );
+      if (collapsedOverlaps.length === 1) {
+        collapsedOverlaps.push(secondOverlap);
+        return collapsedOverlaps;
+      } else {
+        collapsedOverlaps =
+          collapseOverlapsGeneratedFromRangeComparisonIfPossible(
+            [secondOverlap, thirdOverlap],
+            sequenceLength,
+            optionalOriginalRange
+          );
         if (collapsedOverlaps.length === 1) {
-            collapsedOverlaps.push(thirdOverlap);
-            return collapsedOverlaps;
+          collapsedOverlaps.push(firstOverlap);
+          return collapsedOverlaps;
         } else {
-            collapsedOverlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible([firstOverlap, thirdOverlap], sequenceLength, optionalOriginalRange);
-            if (collapsedOverlaps.length === 1) {
-                collapsedOverlaps.push(secondOverlap);
-                return collapsedOverlaps;
-            } else {
-                collapsedOverlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible([secondOverlap, thirdOverlap], sequenceLength, optionalOriginalRange);
-                if (collapsedOverlaps.length === 1) {
-                    collapsedOverlaps.push(firstOverlap);
-                    return collapsedOverlaps;
-                } else {
-                    return overlaps;
-                }
-            }
+          return overlaps;
         }
+      }
     }
-};
+  }
+}

package/src/collapseOverlapsGeneratedFromRangeComparisonIfPossible.test.js

@@ -1,124 +1,223 @@
-import getOverlapsOfPotentiallyCircularRanges from './getOverlapsOfPotentiallyCircularRanges.js';
+import getOverlapsOfPotentiallyCircularRanges from "./getOverlapsOfPotentiallyCircularRanges.js";
 
-import collapseOverlapsGeneratedFromRangeComparisonIfPossible from './collapseOverlapsGeneratedFromRangeComparisonIfPossible.js';
-import assert from 'assert';
+import collapseOverlapsGeneratedFromRangeComparisonIfPossible from "./collapseOverlapsGeneratedFromRangeComparisonIfPossible.js";
+import assert from "assert";
 
-
-;
-describe('collapseOverlapsGeneratedFromRangeComparisonIfPossible', function() {
-    it('returns an empty array if passed an empty array of overlaps', function() {
-        assert.deepEqual(collapseOverlapsGeneratedFromRangeComparisonIfPossible([], 1000), []);
-        assert.deepEqual(collapseOverlapsGeneratedFromRangeComparisonIfPossible(getOverlapsOfPotentiallyCircularRanges({
-            start: 900,
-            end: 100
-        }, {
+describe("collapseOverlapsGeneratedFromRangeComparisonIfPossible", function () {
+  it("returns an empty array if passed an empty array of overlaps", function () {
+    assert.deepEqual(
+      collapseOverlapsGeneratedFromRangeComparisonIfPossible([], 1000),
+      []
+    );
+    assert.deepEqual(
+      collapseOverlapsGeneratedFromRangeComparisonIfPossible(
+        getOverlapsOfPotentiallyCircularRanges(
+          {
             start: 900,
             end: 100
-        }, 1000), 1000), [{
+          },
+          {
             start: 900,
             end: 100
-        }]);
-    });
-    it('collapses a split circular range', function() {
-        assert.deepEqual(collapseOverlapsGeneratedFromRangeComparisonIfPossible([{
+          },
+          1000
+        ),
+        1000
+      ),
+      [
+        {
+          start: 900,
+          end: 100
+        }
+      ]
+    );
+  });
+  it("collapses a split circular range", function () {
+    assert.deepEqual(
+      collapseOverlapsGeneratedFromRangeComparisonIfPossible(
+        [
+          {
             start: 0,
             end: 100
-        }, {
+          },
+          {
             start: 105,
             end: 999
-        }], 1000), [{
-            start: 105,
-            end: 100
-        }]);
-        assert.deepEqual(collapseOverlapsGeneratedFromRangeComparisonIfPossible(getOverlapsOfPotentiallyCircularRanges({
-            start: 900,
-            end: 100
-        }, {
+          }
+        ],
+        1000
+      ),
+      [
+        {
+          start: 105,
+          end: 100
+        }
+      ]
+    );
+    assert.deepEqual(
+      collapseOverlapsGeneratedFromRangeComparisonIfPossible(
+        getOverlapsOfPotentiallyCircularRanges(
+          {
             start: 900,
             end: 100
-        }, 1000), 1000), [{
+          },
+          {
             start: 900,
             end: 100
-        }]);
-    });
-    it('doesnt collapses a split range that could be circular if the originalRangeIsNotCircular', function() {
-        assert.deepEqual(collapseOverlapsGeneratedFromRangeComparisonIfPossible([{
+          },
+          1000
+        ),
+        1000
+      ),
+      [
+        {
+          start: 900,
+          end: 100
+        }
+      ]
+    );
+  });
+  it("doesnt collapses a split range that could be circular if the originalRangeIsNotCircular", function () {
+    assert.deepEqual(
+      collapseOverlapsGeneratedFromRangeComparisonIfPossible(
+        [
+          {
             start: 0,
             end: 100
-        }, {
+          },
+          {
             start: 105,
             end: 999
-        }], 1000, {
-            start: 0,
-            end: 999
-        }), [{
-            start: 0,
-            end: 100
-        }, {
-            start: 105,
-            end: 999
-        }]);
-        assert.deepEqual(collapseOverlapsGeneratedFromRangeComparisonIfPossible(getOverlapsOfPotentiallyCircularRanges({
+          }
+        ],
+        1000,
+        {
+          start: 0,
+          end: 999
+        }
+      ),
+      [
+        {
+          start: 0,
+          end: 100
+        },
+        {
+          start: 105,
+          end: 999
+        }
+      ]
+    );
+    assert.deepEqual(
+      collapseOverlapsGeneratedFromRangeComparisonIfPossible(
+        getOverlapsOfPotentiallyCircularRanges(
+          {
             start: 900,
             end: 100
-        }, {
+          },
+          {
             start: 900,
             end: 100
-        }, 1000), 1000), [{
-            start: 900,
-            end: 100
-        }]);
-    });
-    it('doesnt collapses a split range that doesnt line up correctly', function() {
-        assert.deepEqual(collapseOverlapsGeneratedFromRangeComparisonIfPossible([{
+          },
+          1000
+        ),
+        1000
+      ),
+      [
+        {
+          start: 900,
+          end: 100
+        }
+      ]
+    );
+  });
+  it("doesnt collapses a split range that doesnt line up correctly", function () {
+    assert.deepEqual(
+      collapseOverlapsGeneratedFromRangeComparisonIfPossible(
+        [
+          {
             start: 0,
             end: 100
-        }, {
+          },
+          {
             start: 105,
             end: 998
-        }], 1000),[{
-            start: 0,
-            end: 100
-        }, {
-            start: 105,
-            end: 998
-        }]);
-    });
-    it('collapses a split circular range with a third part', function() {
-        assert.deepEqual(collapseOverlapsGeneratedFromRangeComparisonIfPossible([{
+          }
+        ],
+        1000
+      ),
+      [
+        {
+          start: 0,
+          end: 100
+        },
+        {
+          start: 105,
+          end: 998
+        }
+      ]
+    );
+  });
+  it("collapses a split circular range with a third part", function () {
+    assert.deepEqual(
+      collapseOverlapsGeneratedFromRangeComparisonIfPossible(
+        [
+          {
             start: 200,
             end: 300
-        },{
+          },
+          {
             start: 0,
             end: 100
-        }, {
+          },
+          {
             start: 500,
             end: 999
-        }], 1000), [{
-            start: 500,
-            end: 100
-        },{
-            start: 200,
-            end: 300
-        }]);
-    });
+          }
+        ],
+        1000
+      ),
+      [
+        {
+          start: 500,
+          end: 100
+        },
+        {
+          start: 200,
+          end: 300
+        }
+      ]
+    );
+  });
 
-    it('collapses a split circular range with a third part in a different order', function() {
-        assert.deepEqual(collapseOverlapsGeneratedFromRangeComparisonIfPossible([{
+  it("collapses a split circular range with a third part in a different order", function () {
+    assert.deepEqual(
+      collapseOverlapsGeneratedFromRangeComparisonIfPossible(
+        [
+          {
             start: 0,
             end: 100
-        },{
+          },
+          {
             start: 200,
             end: 300
-        }, {
+          },
+          {
             start: 500,
             end: 999
-        }], 1000), [{
-            start: 500,
-            end: 100
-        },{
-            start: 200,
-            end: 300
-        }]);
-    });
+          }
+        ],
+        1000
+      ),
+      [
+        {
+          start: 500,
+          end: 100
+        },
+        {
+          start: 200,
+          end: 300
+        }
+      ]
+    );
+  });
 });

package/src/convertRangeIndices.js

@@ -1,22 +1,26 @@
-import {assign} from "lodash";
+import { assign } from "lodash";
 
 export default function convertRangeIndices(range, inputType, outputType) {
-    inputType = inputType || {}
-    outputType = outputType || {}
-    return assign({},range,{
-        start: Number(range.start) + (inputType.inclusive1BasedStart 
-            ? outputType.inclusive1BasedStart
-                ? 0
-                : -1
-            : outputType.inclusive1BasedStart
-                ? 1
-                : 0),
-        end: Number(range.end) + (inputType.inclusive1BasedEnd 
-            ? outputType.inclusive1BasedEnd
-                ? 0
-                : -1
-            : outputType.inclusive1BasedEnd
-                ? 1
-                : 0)
-    })
-};
+  inputType = inputType || {};
+  outputType = outputType || {};
+  return assign({}, range, {
+    start:
+      Number(range.start) +
+      (inputType.inclusive1BasedStart
+        ? outputType.inclusive1BasedStart
+          ? 0
+          : -1
+        : outputType.inclusive1BasedStart
+        ? 1
+        : 0),
+    end:
+      Number(range.end) +
+      (inputType.inclusive1BasedEnd
+        ? outputType.inclusive1BasedEnd
+          ? 0
+          : -1
+        : outputType.inclusive1BasedEnd
+        ? 1
+        : 0)
+  });
+}