@teselagen/range-utils 0.3.7 → 0.3.9

package/package.json

@@ -1,9 +1,8 @@
 {
   "name": "@teselagen/range-utils",
-  "version": "0.3.7",
-  "type": "commonjs",
+  "version": "0.3.9",
   "dependencies": {
-    "lodash": "^4.17.21"
+    "lodash-es": "^4.17.21"
   },
   "license": "MIT"
 }

package/src/adjustRangeToDeletionOfAnotherRange.test.js

@@ -1,107 +1,168 @@
+import adjustRangeToDeletionOfAnotherRange from "./adjustRangeToDeletionOfAnotherRange.js";
 
-
-import adjustRangeToDeletionOfAnotherRange from './adjustRangeToDeletionOfAnotherRange.js';
-
-import assert from 'assert';
-describe('adjustRangeToDeletionOfAnotherRange', function() {
-    it('deletes non circular range if fully overlapped', function() {
-        assert.deepEqual(adjustRangeToDeletionOfAnotherRange({
-            start: 10,
-            end: 20
-        }, {
-            start: 10,
-            end: 20
-        }, 30), null);
-    });
-    it('deletes circular range if fully overlapped', function() {
-        assert.deepEqual(adjustRangeToDeletionOfAnotherRange({
-            start: 20,
-            end: 10
-        }, {
-            start: 20,
-            end: 10
-        }, 30), null);
-    });
-    it('shifts start and end if deleting before non circular range', function() {
-        assert.deepEqual(adjustRangeToDeletionOfAnotherRange({
-            name: 'happy',
-            start: 10,
-            end: 20
-        }, {
-            start: 5,
-            end: 8
-        }, 30), {
-            name: 'happy',
-            start: 6,
-            end: 16
-        });
-    });
-    it('shifts start if deleting in middle of non circular range', function() {
-        assert.deepEqual(adjustRangeToDeletionOfAnotherRange({
-            name: 'happy',
-            start: 20,
-            end: 10
-        }, {
-            start: 15,
-            end: 20
-        }, 30), {
-            name: 'happy',
-            start: 15,
-            end: 10
-        });
-        assert.deepEqual(adjustRangeToDeletionOfAnotherRange({
-            start: 20,
-            end: 10
-        }, {
-            start: 15,
-            end: 15
-        }, 30), {
-            start: 19,
-            end: 10
-        });
-    });
-    it('shifts start and end if deleting before end of non circular range', function() {
-        assert.deepEqual(adjustRangeToDeletionOfAnotherRange({
-            start: 20,
-            end: 10
-        }, {
-            start: 0,
-            end: 0
-        }, 30), {
-            start: 19,
-            end: 9
-        });
-        assert.deepEqual(adjustRangeToDeletionOfAnotherRange({
-            start: 20,
-            end: 10
-        }, {
-            start: 5,
-            end: 15
-        }, 30), {
-            start: 9,
-            end: 4
-        });
-    });
-    it('shifts neither start nor end if deleting after start of non circular range', function() {
-        assert.deepEqual(adjustRangeToDeletionOfAnotherRange({
-            start: 20,
-            end: 10
-        }, {
-            start: 25,
-            end: 27
-        }, 30), {
-            start: 20,
-            end: 10
-        });
-        assert.deepEqual(adjustRangeToDeletionOfAnotherRange({
-            start: 20,
-            end: 10
-        }, {
-            start: 20,
-            end: 25
-        }, 30), {
-            start: 20,
-            end: 10
-        });
-    });
+import assert from "assert";
+describe("adjustRangeToDeletionOfAnotherRange", function () {
+  it("deletes non circular range if fully overlapped", function () {
+    assert.deepEqual(
+      adjustRangeToDeletionOfAnotherRange(
+        {
+          start: 10,
+          end: 20
+        },
+        {
+          start: 10,
+          end: 20
+        },
+        30
+      ),
+      null
+    );
+  });
+  it("deletes circular range if fully overlapped", function () {
+    assert.deepEqual(
+      adjustRangeToDeletionOfAnotherRange(
+        {
+          start: 20,
+          end: 10
+        },
+        {
+          start: 20,
+          end: 10
+        },
+        30
+      ),
+      null
+    );
+  });
+  it("shifts start and end if deleting before non circular range", function () {
+    assert.deepEqual(
+      adjustRangeToDeletionOfAnotherRange(
+        {
+          name: "happy",
+          start: 10,
+          end: 20
+        },
+        {
+          start: 5,
+          end: 8
+        },
+        30
+      ),
+      {
+        name: "happy",
+        start: 6,
+        end: 16
+      }
+    );
+  });
+  it("shifts start if deleting in middle of non circular range", function () {
+    assert.deepEqual(
+      adjustRangeToDeletionOfAnotherRange(
+        {
+          name: "happy",
+          start: 20,
+          end: 10
+        },
+        {
+          start: 15,
+          end: 20
+        },
+        30
+      ),
+      {
+        name: "happy",
+        start: 15,
+        end: 10
+      }
+    );
+    assert.deepEqual(
+      adjustRangeToDeletionOfAnotherRange(
+        {
+          start: 20,
+          end: 10
+        },
+        {
+          start: 15,
+          end: 15
+        },
+        30
+      ),
+      {
+        start: 19,
+        end: 10
+      }
+    );
+  });
+  it("shifts start and end if deleting before end of non circular range", function () {
+    assert.deepEqual(
+      adjustRangeToDeletionOfAnotherRange(
+        {
+          start: 20,
+          end: 10
+        },
+        {
+          start: 0,
+          end: 0
+        },
+        30
+      ),
+      {
+        start: 19,
+        end: 9
+      }
+    );
+    assert.deepEqual(
+      adjustRangeToDeletionOfAnotherRange(
+        {
+          start: 20,
+          end: 10
+        },
+        {
+          start: 5,
+          end: 15
+        },
+        30
+      ),
+      {
+        start: 9,
+        end: 4
+      }
+    );
+  });
+  it("shifts neither start nor end if deleting after start of non circular range", function () {
+    assert.deepEqual(
+      adjustRangeToDeletionOfAnotherRange(
+        {
+          start: 20,
+          end: 10
+        },
+        {
+          start: 25,
+          end: 27
+        },
+        30
+      ),
+      {
+        start: 20,
+        end: 10
+      }
+    );
+    assert.deepEqual(
+      adjustRangeToDeletionOfAnotherRange(
+        {
+          start: 20,
+          end: 10
+        },
+        {
+          start: 20,
+          end: 25
+        },
+        30
+      ),
+      {
+        start: 20,
+        end: 10
+      }
+    );
+  });
 });

package/src/adjustRangeToInsert.js

@@ -1,28 +1,31 @@
+import { assign } from "lodash-es";
 
-import {assign} from "lodash";
-
-export default function adjustRangeToInsert(rangeToBeAdjusted, insertStart, insertLength) {
-    // ac.throw([ac.range, ac.posInt, ac.posInt], arguments);
-    const newRange = assign({}, rangeToBeAdjusted);
-    if (rangeToBeAdjusted.start > rangeToBeAdjusted.end) {
-        //circular range
-        if (rangeToBeAdjusted.end >= insertStart) {
-            //adjust both start and end
-            newRange.start += insertLength;
-            newRange.end += insertLength;
-        } else if (rangeToBeAdjusted.start >= insertStart) {
-            //adjust just the start
-            newRange.start += insertLength;
-        }
-    } else {
-        if (rangeToBeAdjusted.start >= insertStart) {
-            //adjust both start and end
-            newRange.start += insertLength;
-            newRange.end += insertLength;
-        } else if (rangeToBeAdjusted.end >= insertStart) {
-            //adjust just the end
-            newRange.end += insertLength;
-        }
+export default function adjustRangeToInsert(
+  rangeToBeAdjusted,
+  insertStart,
+  insertLength
+) {
+  // ac.throw([ac.range, ac.posInt, ac.posInt], arguments);
+  const newRange = assign({}, rangeToBeAdjusted);
+  if (rangeToBeAdjusted.start > rangeToBeAdjusted.end) {
+    //circular range
+    if (rangeToBeAdjusted.end >= insertStart) {
+      //adjust both start and end
+      newRange.start += insertLength;
+      newRange.end += insertLength;
+    } else if (rangeToBeAdjusted.start >= insertStart) {
+      //adjust just the start
+      newRange.start += insertLength;
+    }
+  } else {
+    if (rangeToBeAdjusted.start >= insertStart) {
+      //adjust both start and end
+      newRange.start += insertLength;
+      newRange.end += insertLength;
+    } else if (rangeToBeAdjusted.end >= insertStart) {
+      //adjust just the end
+      newRange.end += insertLength;
     }
-    return newRange;
-};
+  }
+  return newRange;
+}

package/src/adjustRangeToInsert.test.js

@@ -1,111 +1,199 @@
+import adjustRangeToInsert from "./adjustRangeToInsert.js";
 
-
-
-import adjustRangeToInsert from './adjustRangeToInsert.js';
-
-import assert from 'assert';
-describe('adjustRangeToInsert', function() {
-    it('shifts start and end if inserting before non circular range', function() {
-        assert.deepEqual(adjustRangeToInsert({
-            start: 10,
-            end: 20
-        }, 4, 5), {
-            start: 15,
-            end: 25
-        });
-        assert.deepEqual(adjustRangeToInsert({
-            start: 10,
-            end: 20
-        }, 10, 5), {
-            start: 15,
-            end: 25
-        });
-        assert.deepEqual(adjustRangeToInsert({
-            start: 10,
-            end: 20
-        }, 0, 5), {
-            start: 15,
-            end: 25
-        });
-    });
-    it('shifts end if inserting in middle of non circular range', function() {
-        assert.deepEqual(adjustRangeToInsert({
-            start: 10,
-            end: 20
-        }, 11, 5), {
-            start: 10,
-            end: 25
-        });
-        assert.deepEqual(adjustRangeToInsert({
-            start: 10,
-            end: 20
-        }, 20, 5), {
-            start: 10,
-            end: 25
-        });
-    });
-    it('shifts neither start nor end if inserting in after end of non circular range', function() {
-        assert.deepEqual(adjustRangeToInsert({
-            start: 10,
-            end: 20
-        }, 24, 5), {
-            start: 10,
-            end: 20
-        });
-        assert.deepEqual(adjustRangeToInsert({
-            start: 10,
-            end: 20
-        }, 21, 5), {
-            start: 10,
-            end: 20
-        });
-    });
-    it('shifts neither start nor end if inserting in after start of circular range', function() {
-        assert.deepEqual(adjustRangeToInsert({
-            start: 20,
-            end: 10
-        }, 24, 5), {
-            start: 20,
-            end: 10
-        });
-        assert.deepEqual(adjustRangeToInsert({
-            start: 20,
-            end: 10
-        }, 21, 5), {
-            start: 20,
-            end: 10
-        });
-    });
-    it('shifts both start and end if inserting in before end of circular range', function() {
-        assert.deepEqual(adjustRangeToInsert({
-            start: 20,
-            end: 10
-        }, 5, 5), {
-            start: 25,
-            end: 15
-        });
-        assert.deepEqual(adjustRangeToInsert({
-            start: 20,
-            end: 10
-        }, 10, 5), {
-            start: 25,
-            end: 15
-        });
-    });
-    it('shifts just start if inserting in after end but before start of circular range', function() {
-        assert.deepEqual(adjustRangeToInsert({
-            start: 20,
-            end: 10
-        }, 11, 5), {
-            start: 25,
-            end: 10
-        });
-        assert.deepEqual(adjustRangeToInsert({
-            start: 20,
-            end: 10
-        }, 20, 5), {
-            start: 25,
-            end: 10
-        });
-    });
+import assert from "assert";
+describe("adjustRangeToInsert", function () {
+  it("shifts start and end if inserting before non circular range", function () {
+    assert.deepEqual(
+      adjustRangeToInsert(
+        {
+          start: 10,
+          end: 20
+        },
+        4,
+        5
+      ),
+      {
+        start: 15,
+        end: 25
+      }
+    );
+    assert.deepEqual(
+      adjustRangeToInsert(
+        {
+          start: 10,
+          end: 20
+        },
+        10,
+        5
+      ),
+      {
+        start: 15,
+        end: 25
+      }
+    );
+    assert.deepEqual(
+      adjustRangeToInsert(
+        {
+          start: 10,
+          end: 20
+        },
+        0,
+        5
+      ),
+      {
+        start: 15,
+        end: 25
+      }
+    );
+  });
+  it("shifts end if inserting in middle of non circular range", function () {
+    assert.deepEqual(
+      adjustRangeToInsert(
+        {
+          start: 10,
+          end: 20
+        },
+        11,
+        5
+      ),
+      {
+        start: 10,
+        end: 25
+      }
+    );
+    assert.deepEqual(
+      adjustRangeToInsert(
+        {
+          start: 10,
+          end: 20
+        },
+        20,
+        5
+      ),
+      {
+        start: 10,
+        end: 25
+      }
+    );
+  });
+  it("shifts neither start nor end if inserting in after end of non circular range", function () {
+    assert.deepEqual(
+      adjustRangeToInsert(
+        {
+          start: 10,
+          end: 20
+        },
+        24,
+        5
+      ),
+      {
+        start: 10,
+        end: 20
+      }
+    );
+    assert.deepEqual(
+      adjustRangeToInsert(
+        {
+          start: 10,
+          end: 20
+        },
+        21,
+        5
+      ),
+      {
+        start: 10,
+        end: 20
+      }
+    );
+  });
+  it("shifts neither start nor end if inserting in after start of circular range", function () {
+    assert.deepEqual(
+      adjustRangeToInsert(
+        {
+          start: 20,
+          end: 10
+        },
+        24,
+        5
+      ),
+      {
+        start: 20,
+        end: 10
+      }
+    );
+    assert.deepEqual(
+      adjustRangeToInsert(
+        {
+          start: 20,
+          end: 10
+        },
+        21,
+        5
+      ),
+      {
+        start: 20,
+        end: 10
+      }
+    );
+  });
+  it("shifts both start and end if inserting in before end of circular range", function () {
+    assert.deepEqual(
+      adjustRangeToInsert(
+        {
+          start: 20,
+          end: 10
+        },
+        5,
+        5
+      ),
+      {
+        start: 25,
+        end: 15
+      }
+    );
+    assert.deepEqual(
+      adjustRangeToInsert(
+        {
+          start: 20,
+          end: 10
+        },
+        10,
+        5
+      ),
+      {
+        start: 25,
+        end: 15
+      }
+    );
+  });
+  it("shifts just start if inserting in after end but before start of circular range", function () {
+    assert.deepEqual(
+      adjustRangeToInsert(
+        {
+          start: 20,
+          end: 10
+        },
+        11,
+        5
+      ),
+      {
+        start: 25,
+        end: 10
+      }
+    );
+    assert.deepEqual(
+      adjustRangeToInsert(
+        {
+          start: 20,
+          end: 10
+        },
+        20,
+        5
+      ),
+      {
+        start: 25,
+        end: 10
+      }
+    );
+  });
 });

package/src/adjustRangeToRotation.js

@@ -1,7 +1,6 @@
+import { assign } from "lodash-es";
 
-import {assign} from "lodash";
-
-import {identity} from 'lodash';
+import { identity } from "lodash-es";
 
 export default function adjustRangeToRotation(
   rangeToBeAdjusted,
@@ -9,7 +8,7 @@ export default function adjustRangeToRotation(
   rangeLength
 ) {
   // ac.throw([ac.range, ac.posInt, ac.posInt], arguments);
-  const mod = rangeLength ? modulo : identity
+  const mod = rangeLength ? modulo : identity;
 
   const newRange = assign({}, rangeToBeAdjusted, {
     start: mod(rangeToBeAdjusted.start - (rotateTo || 0), rangeLength),
@@ -17,7 +16,7 @@ export default function adjustRangeToRotation(
   });
 
   return newRange;
-};
+}
 
 function modulo(n, m) {
   return ((n % m) + m) % m;