@teselagen/range-utils 0.1.21 → 0.1.22

package/src/trimRangeByAnotherRange.test.js

@@ -0,0 +1,314 @@
+import trimRangeByAnotherRange from "./trimRangeByAnotherRange.js";
+import assert from "assert";
+
+describe("trimRangeByAnotherRange", function() {
+  it(`returns nothing if invalid inputs are sent in`, () => {
+    assert.equal(
+      null,
+      trimRangeByAnotherRange(
+        null,
+        {
+          start: 2,
+          end: 2
+        },
+        10
+      )
+    );
+  });
+  it("trims non circular ranges that dont fully overlap", function() {
+    assert.deepEqual(
+      trimRangeByAnotherRange(
+        {
+          start: 0,
+          end: 2,
+          name: "happy"
+        },
+        {
+          start: 2,
+          end: 2
+        },
+        10
+      ),
+      {
+        start: 0,
+        end: 1,
+        name: "happy"
+      }
+    );
+  });
+  it("it does not trim non circular ranges with overlap contained within it", function() {
+    assert.deepEqual(
+      trimRangeByAnotherRange(
+        {
+          start: 0,
+          end: 10,
+          name: "happy"
+        },
+        {
+          start: 2,
+          end: 2
+        },
+        10
+      ),
+      {
+        start: 0,
+        end: 10,
+        name: "happy"
+      }
+    );
+  });
+  it("trims non circular ranges that fully overlap", function() {
+    assert.deepEqual(
+      trimRangeByAnotherRange(
+        {
+          start: 0,
+          end: 2
+        },
+        {
+          start: 0,
+          end: 2
+        },
+        10
+      ),
+      undefined
+    );
+    assert.deepEqual(
+      trimRangeByAnotherRange(
+        {
+          start: 3,
+          end: 5
+        },
+        {
+          start: 3,
+          end: 5
+        },
+        10
+      ),
+      undefined
+    );
+    assert.deepEqual(
+      trimRangeByAnotherRange(
+        {
+          start: 3,
+          end: 3
+        },
+        {
+          start: 3,
+          end: 3
+        },
+        10
+      ),
+      undefined
+    );
+    assert.deepEqual(
+      trimRangeByAnotherRange(
+        {
+          start: 0,
+          end: 0
+        },
+        {
+          start: 0,
+          end: 3
+        },
+        10
+      ),
+      undefined
+    );
+  });
+  it("does not trim non circular ranges that dont overlap", function() {
+    assert.deepEqual(
+      trimRangeByAnotherRange(
+        {
+          start: 0,
+          end: 2
+        },
+        {
+          start: 5,
+          end: 6
+        },
+        10
+      ),
+      {
+        start: 0,
+        end: 2
+      }
+    );
+    assert.deepEqual(
+      trimRangeByAnotherRange(
+        {
+          start: 3,
+          end: 5,
+          name: "happy"
+        },
+        {
+          start: 0,
+          end: 0
+        },
+        10
+      ),
+      {
+        start: 3,
+        name: "happy",
+        end: 5
+      }
+    );
+  });
+  it("does trim circular ranges that overlap", function() {
+    assert.deepEqual(
+      trimRangeByAnotherRange(
+        {
+          start: 3,
+          name: "happy",
+          end: 2
+        },
+        {
+          start: 5,
+          end: 6
+        },
+        10
+      ),
+      {
+        start: 3,
+        name: "happy",
+        end: 2
+      }
+    );
+    assert.deepEqual(
+      trimRangeByAnotherRange(
+        {
+          start: 3,
+          end: 2
+        },
+        {
+          start: 3,
+          end: 6
+        },
+        10
+      ),
+      {
+        start: 7,
+        end: 2
+      }
+    );
+    assert.deepEqual(
+      trimRangeByAnotherRange(
+        {
+          start: 3,
+          end: 2
+        },
+        {
+          start: 1,
+          end: 6
+        },
+        10
+      ),
+      {
+        start: 7,
+        end: 0
+      }
+    );
+    assert.deepEqual(
+      trimRangeByAnotherRange(
+        {
+          start: 3,
+          end: 2
+        },
+        {
+          start: 0,
+          end: 6
+        },
+        10
+      ),
+      {
+        start: 7,
+        end: 9
+      }
+    );
+    assert.deepEqual(
+      trimRangeByAnotherRange(
+        {
+          start: 3,
+          end: 2
+        },
+        {
+          start: 2,
+          end: 9
+        },
+        10
+      ),
+      {
+        start: 0,
+        end: 1
+      }
+    );
+    assert.deepEqual(
+      trimRangeByAnotherRange(
+        {
+          start: 3,
+          end: 2
+        },
+        // rrrrrrrrrr
+        // 0123456789
+        // --es------
+        // --e s-----
+        {
+          start: 4,
+          end: 2
+        },
+        10
+      ),
+      {
+        start: 3,
+        end: 3
+      }
+    );
+    assert.deepEqual(
+      trimRangeByAnotherRange(
+        {
+          start: 1,
+          end: 2
+        },
+        {
+          start: 4,
+          end: 1
+        },
+        10
+      ),
+      {
+        start: 2,
+        end: 2
+      }
+    );
+    assert.deepEqual(
+      trimRangeByAnotherRange(
+        {
+          start: 1,
+          end: 5
+        },
+        {
+          start: 4,
+          end: 1
+        },
+        10
+      ),
+      {
+        start: 2,
+        end: 3
+      }
+    );
+    assert.deepEqual(
+      trimRangeByAnotherRange(
+        {
+          start: 3,
+          end: 2
+        },
+        {
+          start: 3,
+          end: 2
+        },
+        10
+      ),
+      undefined
+    );
+  });
+});

package/src/zeroSubrangeByContainerRange.js

@@ -0,0 +1,36 @@
+//
+// ac.throw([ac.posInt, ac.posInt, ac.bool], arguments);
+import trimRangeByAnotherRange from './trimRangeByAnotherRange';
+
+/**
+ * "zeroes" a subrange of a container range by
+ * adjusting subRange start and end such that it is as if the container range start = 0.
+ * @param  {object} subRange  {start:
+ *                                     end:
+ *                                     }
+ * @param  {object} containerRange {start:
+ *                                     end:
+ *                                     }
+ * @param  {int} sequenceLength
+ * @return {object}                {start:
+ *                                     end:
+ *                                     }
+ */
+export default function zeroSubrangeByContainerRange(subRange, containerRange, sequenceLength) {
+    // ac.throw([ac.range, ac.range, ac.posInt], arguments);
+    //first check to make sure the container range fully contains the subRange
+    const trimmedSubRange = trimRangeByAnotherRange(subRange, containerRange, sequenceLength);
+    if (trimmedSubRange) {
+        throw new Error('subRange must be fully contained by containerRange! Otherwise this function does not make sense');
+    }
+    const newSubrange = {};
+    newSubrange.start = subRange.start - containerRange.start;
+    newSubrange.end = subRange.end - containerRange.start;
+    if (newSubrange.start < 0) {
+        newSubrange.start += sequenceLength;
+    }
+    if (newSubrange.end < 0) {
+        newSubrange.end += sequenceLength;
+    }
+    return newSubrange;
+};

package/src/zeroSubrangeByContainerRange.test.js

@@ -0,0 +1,51 @@
+
+
+import {expect} from 'chai';
+
+import zeroSubrangeByContainerRange from './zeroSubrangeByContainerRange.js';
+describe('zeroSubrangeByContainerRange', function() {
+    it('throws an error if circular subRange does not fit within container range', function() {
+        let error = false;
+        try {
+            zeroSubrangeByContainerRange({
+                start: 20,
+                end: 10
+            }, {
+                start: 10,
+                end: 20
+            }, 30);
+        } catch (e) {
+            error = true;
+        }
+        expect(error).to.be.true;
+    });
+    it('throws an error if non circular subRange does not fit within container range', function() {
+        let error = false;
+        try {
+            zeroSubrangeByContainerRange({
+                start: 9,
+                end: 20
+            }, {
+                start: 10,
+                end: 20
+            }, 30);
+        } catch (e) {
+            error = true;
+        }
+        expect(error).to.be.true;
+    });
+    it('zeros non circular range if fully overlapped', function() {
+        const zeroedSubrange = zeroSubrangeByContainerRange({
+            start: 10,
+            end: 20
+        }, {
+            start: 10,
+            end: 20
+        }, 30);
+
+        expect(zeroedSubrange).to.deep.equal({
+            start: 0,
+            end: 10
+        });
+    });
+});