@teselagen/range-utils 0.1.21 → 0.1.23

package/src/collapseOverlapsGeneratedFromRangeComparisonIfPossible.test.js

@@ -0,0 +1,124 @@
+import getOverlapsOfPotentiallyCircularRanges from './getOverlapsOfPotentiallyCircularRanges.js';
+
+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
+        }, {
+            start: 900,
+            end: 100
+        }, 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
+        }, {
+            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([{
+            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({
+            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([{
+            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([{
+            start: 200,
+            end: 300
+        },{
+            start: 0,
+            end: 100
+        }, {
+            start: 500,
+            end: 999
+        }], 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([{
+            start: 0,
+            end: 100
+        },{
+            start: 200,
+            end: 300
+        }, {
+            start: 500,
+            end: 999
+        }], 1000), [{
+            start: 500,
+            end: 100
+        },{
+            start: 200,
+            end: 300
+        }]);
+    });
+});

package/src/convertRangeIndices.js

@@ -0,0 +1,22 @@
+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)
+    })
+};

package/src/convertRangeIndices.test.js

@@ -0,0 +1,22 @@
+import convertRangeIndices from './convertRangeIndices';
+import chai from 'chai';
+chai.should();
+describe('convertRangeIndices', function () {
+	it('should correctly convert various types of ranges', function () {
+		convertRangeIndices({start: 9,end:0},{inclusive1BasedStart: true}).should.deep.equal({start: 8,end: 0})
+		convertRangeIndices({start: 9,end:0},{inclusive1BasedStart: true}, {inclusive1BasedEnd: true}).should.deep.equal({start: 8,end: 1})
+		convertRangeIndices({start: 9,end:0},{inclusive1BasedEnd: true}, {inclusive1BasedEnd: true}).should.deep.equal({start: 9,end: 0})
+		convertRangeIndices({start: 4,end:5},{inclusive1BasedEnd: true}, {inclusive1BasedStart: true}).should.deep.equal({start: 5,end: 4})
+		convertRangeIndices({
+                start: '1',
+                end: '28',
+            },
+            {inclusive1BasedStart: true, inclusive1BasedEnd: true},
+            {})
+            .should.deep.equal({start: 0,end: 27})
+	});
+    it('should not remove other attributes on the range object', function () {
+    	convertRangeIndices({start: 4,end:5, someOtherAttribute: 'yay'},{inclusive1BasedEnd: true}, {inclusive1BasedStart: true})
+            .should.deep.equal({start: 5,end: 4, someOtherAttribute: 'yay'})
+	});
+})

package/src/convertRangeTo0Based.js

@@ -0,0 +1,5 @@
+import convertRangeIndices from './convertRangeIndices';
+
+export default function convertRangeTo0Based (range) {
+  return convertRangeIndices(range, {inclusive1BasedStart: true, inclusive1BasedEnd: true})
+};

package/src/convertRangeTo1Based.js

@@ -0,0 +1,5 @@
+import convertRangeIndices from './convertRangeIndices';
+
+export default function convertRangeTo1Based (range) {
+  return convertRangeIndices(range, {}, {inclusive1BasedStart: true, inclusive1BasedEnd: true})
+};

package/src/doesRangeSpanEntireSequence.js

@@ -0,0 +1,7 @@
+import getRangeLength from './getRangeLength';
+
+export default function doesRangeSpanEntireSequence (range, sequenceLength) {
+  if (getRangeLength(range) === sequenceLength) {
+  	return true
+  }
+};

package/src/doesRangeSpanOrigin.js

@@ -0,0 +1,3 @@
+export default function doesRangeSpanOrigin (range) {
+  return range.start > range.end
+};

package/src/expandOrContractCircularRangeToPosition.js

@@ -0,0 +1,41 @@
+import normalizePositionByRangeLength from './normalizePositionByRangeLength';
+import {assign} from "lodash";
+
+export default function expandOrContractCircularRangeToPosition(range, position, maxLength) {
+
+    // 0 1 2 3 4 5 6 7 8 9
+    // r r r r r - - r r r
+    //0 1 2 3 4 5 6 7 8 9 10
+    //        | 
+    const newRange = assign({}, range);
+    let endMoved = true;
+    if (range.end >= position) {
+        if (position + maxLength - range.start > range.end - position) {
+            newRange.end = normalizePositionByRangeLength(position - 1, maxLength, false);
+        } else {
+            newRange.start = position;
+            endMoved = false;
+        }
+    } else {
+        if (range.start < position) {
+            if (range.end + maxLength - position > position - range.start) {
+                newRange.start = position;
+                endMoved = false;
+            } else {
+                newRange.end = position - 1;
+            }
+        } else {
+            //position somewhere between end and start
+            if (range.start - position > position - range.end) {
+                newRange.end = position - 1;
+            } else {
+                endMoved = false;
+                newRange.start = position;
+            }
+        }
+    }
+    return ({
+        newRange: newRange, 
+        endMoved: endMoved
+    })
+};

package/src/expandOrContractNonCircularRangeToPosition.js

@@ -0,0 +1,25 @@
+import {assign} from "lodash";
+
+export default function expandOrContractNonCircularRangeToPosition (range, position) {
+    const newRange = assign({},range);
+    let endMoved = true;
+    if (range.start > position) {
+        newRange.start = position;
+        endMoved = false;
+    } else {
+        if (range.end < position) {
+            newRange.end = position - 1;
+        } else {
+            if (position - range.start > range.end - position) {
+                newRange.end = position - 1;
+            } else {
+                newRange.start = position;
+                endMoved = false;
+            }
+        }
+    }
+    return ({
+        newRange: newRange,
+        endMoved: endMoved
+    })
+};

package/src/expandOrContractRangeByLength.js

@@ -0,0 +1,12 @@
+import {clone} from 'lodash';
+import normalizeRange from './normalizeRange';
+
+export default function expandOrContractRangeByLength(range, shiftBy, shiftStart, sequenceLength) {
+    const rangeToReturn = clone(range);
+    if (shiftStart) {
+    	rangeToReturn.start -=shiftBy
+    } else {
+    	rangeToReturn.end +=shiftBy
+    }
+    return normalizeRange(rangeToReturn,sequenceLength)
+};

package/src/expandOrContractRangeByLength.test.js

@@ -0,0 +1,77 @@
+import expandOrContractRangeByLength from './expandOrContractRangeByLength';
+import chai from 'chai';
+const expect = chai.expect;
+chai.should();
+
+describe('expandOrContractRangeByLength', function () {
+	it('shift start by 1 ', function () {
+		const expandedRange = expandOrContractRangeByLength({start: 3,end:4}, 1, true, 10);
+		expandedRange.should.deep.equal({
+			start: 2,
+			end: 4
+		})
+	});
+	it('shift end by 1 ', function () {
+		const expandedRange = expandOrContractRangeByLength({start: 3,end:4}, 1, false, 10);
+		expandedRange.should.deep.equal({
+			start: 3,
+			end: 5
+		})
+	});
+	it('shift end by 6 ', function () {
+		const expandedRange = expandOrContractRangeByLength({start: 3,end:4}, 6, false, 10);
+		expandedRange.should.deep.equal({
+			start: 3,
+			end: 0
+		})
+	});
+
+	it('circular range', function () {
+		const expandedRange = expandOrContractRangeByLength({start: 6,end:4}, 1, false, 10);
+		expandedRange.should.deep.equal({
+			start: 6,
+			end: 5
+		})
+	});
+	it('circular range', function () {
+		const expandedRange = expandOrContractRangeByLength({start: 6,end:4}, 1, true, 10);
+		expandedRange.should.deep.equal({
+			start: 5,
+			end: 4
+		})
+	});
+	it('circular range', function () {
+		const expandedRange = expandOrContractRangeByLength({start: 6,end:4}, 1, true, 10);
+		expandedRange.should.deep.equal({
+			start: 5,
+			end: 4
+		})
+	});
+
+	it('negative shiftBy', function () {
+		const expandedRange = expandOrContractRangeByLength({start: 6,end:4}, -1, true, 10);
+		expandedRange.should.deep.equal({
+			start: 7,
+			end: 4
+		})
+	});
+	it('negative shiftBy', function () {
+		const expandedRange = expandOrContractRangeByLength({start: 6,end:4}, -1, false, 10);
+		expandedRange.should.deep.equal({
+			start: 6,
+			end: 3
+		})
+	});
+
+	// it('should error if trying to expand more than possible', function () {
+	// 	var error = false;
+	// 	try {
+	// 		var range = expandOrContractRangeByLength({start: 6,end:4}, 10, false, 10)
+	// 		console.log('range:', range)
+	// 	} catch (e) {
+	// 	    error = true;
+	// 	}
+	// 	expect(error).to.be.true;
+	// });
+});
+

package/src/expandOrContractRangeToPosition.js

@@ -0,0 +1,10 @@
+import expandOrContractCircularRangeToPosition from './expandOrContractCircularRangeToPosition';
+import expandOrContractNonCircularRangeToPosition from './expandOrContractNonCircularRangeToPosition';
+
+export default function expandOrContractRangeToPosition(range, position, maxLength) {
+    if (range.start > range.end) {
+        return expandOrContractCircularRangeToPosition(range, position, maxLength)
+    } else {
+        return expandOrContractNonCircularRangeToPosition(range, position, maxLength)
+    }
+};

package/src/flipContainedRange.js

@@ -0,0 +1,85 @@
+import expandOrContractRangeByLength from './expandOrContractRangeByLength';
+import isRangeWithinRange from './isRangeWithinRange';
+import getOverlapsOfPotentiallyCircularRanges from './getOverlapsOfPotentiallyCircularRanges';
+import translateRange from './translateRange';
+import getRangeLength from './getRangeLength';
+
+export default function flipRelativeRange(innerRange, outerRange, sequenceLength, options) {
+	const isFullyContained = isRangeWithinRange(innerRange,outerRange,sequenceLength);
+	if (isFullyContained) {
+		return flipFullyContainedRange(innerRange,outerRange,sequenceLength)
+	}
+	else {
+		// flip not fully contained range
+		return flipNonFullyContainedRange(innerRange,outerRange,sequenceLength)
+	}
+};
+
+function flipNonFullyContainedRange(innerRange, outerRange, sequenceLength, options) {
+	const outerFullyContained = isRangeWithinRange(outerRange, innerRange,sequenceLength);
+	let flippedInnerRange;
+	if (outerFullyContained) {
+		//special logic
+		// flipFullyContainedRange(outerRange, outerRange, sequenceLength)
+		const expandBy1 = getRangeLength({
+					start: innerRange.start,
+					end: outerRange.start
+				},sequenceLength) - 1;
+		flippedInnerRange = expandOrContractRangeByLength(outerRange, expandBy1, false, sequenceLength)
+
+		const expandBy2 = getRangeLength({
+					end: innerRange.end,
+					start: outerRange.end
+				},sequenceLength) - 1;
+		flippedInnerRange = expandOrContractRangeByLength(flippedInnerRange, expandBy2, true, sequenceLength)
+	} else {
+		//find overlaps of ranges
+		const overlaps = getOverlapsOfPotentiallyCircularRanges(innerRange, outerRange, sequenceLength);
+		//take first overlap and determine which end of outer range it overlaps
+		if (overlaps.length >= 1) {
+			let overlapExtendsForward;
+			const firstOverlap = overlaps[0];
+			overlapExtendsForward = firstOverlap.start !== outerRange.start
+			//flip using fully contained logic
+			const flippedTruncatedInner = flipFullyContainedRange(firstOverlap, outerRange, sequenceLength);
+			//extend in the opposite direction
+			const lengthToExtend = getRangeLength(innerRange,sequenceLength) - getRangeLength(flippedTruncatedInner, sequenceLength);
+			flippedInnerRange = expandOrContractRangeByLength(flippedTruncatedInner, lengthToExtend, overlapExtendsForward, sequenceLength)
+		} else {
+			throw new Error('This case (relative ranges that do not overlap) is unsupported! ')
+		}
+	}
+	return flippedInnerRange
+}
+
+function flipFullyContainedRange(innerRange, outerRange, sequenceLength, options) {
+	//translate both ranges by offset such that outer range start = 0
+	const translateBy = -outerRange.start;
+	const translatedOuterRange = translateRange(outerRange, translateBy, sequenceLength);
+	const translatedInnerRange = translateRange(innerRange, translateBy, sequenceLength);
+
+	//flip like non origin spanning range 
+	const translatedFlippedInnerRange = flipNonOriginSpanningContainedRange(translatedInnerRange, translatedOuterRange, sequenceLength);
+
+	//translate inner range back by negative offset 
+	const flippedInnerRange = translateRange(translatedFlippedInnerRange, -translateBy, sequenceLength);
+	return flippedInnerRange
+}
+
+function flipNonOriginSpanningContainedRange(innerRange, outerRange, sequenceLength) {
+    //non origin spanning, fully contained inner
+    const offsetFromStart = innerRange.start - outerRange.start;
+    const newInnerEnd = outerRange.end - offsetFromStart;
+		const innerRangeLength = getRangeLength(innerRange, sequenceLength);
+
+    return {
+		end: newInnerEnd,
+		start: newInnerEnd - (innerRangeLength -1)
+    }
+}
+
+
+
+
+//take 2
+

package/src/flipContainedRange.test.js

@@ -0,0 +1,124 @@
+/* eslint-disable no-var*/
+import flipContainedRange from './flipContainedRange';
+
+import chai from 'chai';
+chai.should();
+
+describe('flipContainedRange', function () {
+	it('non origin spanning, fully contained inner', function () {
+		const innerRange ={
+			start: 5,
+			end: 13
+		};
+		const outerRange = {
+			start: 0,
+			end:20
+		};
+		const sequenceLength = 40;
+		const flippedInnerRange = flipContainedRange(innerRange, outerRange, sequenceLength);
+		flippedInnerRange.should.deep.equal({
+			start: 7,
+			end:15
+		})
+	});
+	it('non origin spanning outer, origin spanning fully contained inner', function () {
+		const innerRange ={
+			start: 3,
+			end: 1
+		};
+		const outerRange = {
+			start: 0,
+			end:3
+		};
+		const sequenceLength = 4;
+		const flippedInnerRange = flipContainedRange(innerRange, outerRange, sequenceLength);
+		flippedInnerRange.should.deep.equal({
+			start: 2,
+			end:0
+		})
+	});
+	it('origin spanning outer, non-origin spanning, fully contained inner', function () {
+		const innerRange ={
+			start: 1,
+			end: 3
+		};
+		const outerRange = {
+			start: 8,
+			end:5
+		};
+		const sequenceLength = 10;
+		const flippedInnerRange = flipContainedRange(innerRange, outerRange, sequenceLength);
+		flippedInnerRange.should.deep.equal({
+			start: 0,
+			end:2
+		})
+	});
+	it('non-origin spanning outer, non-origin spanning, non-fully contained inner', function () {
+		const innerRange ={
+			start: 1,
+			end: 4
+		};
+		const outerRange = {
+			start: 3,
+			end:6
+		};
+		const sequenceLength = 10;
+		const flippedInnerRange = flipContainedRange(innerRange, outerRange, sequenceLength);
+		flippedInnerRange.should.deep.equal({
+			start: 5,
+			end:8
+		})
+	});
+	it('non-origin spanning outer, non-origin spanning, non-fully contained inner', function () {
+		const innerRange ={
+			start: 4,
+			end: 2
+		};
+		const outerRange = {
+			start: 2,
+			end:5
+		};
+		const sequenceLength = 10;
+		const flippedInnerRange = flipContainedRange(innerRange, outerRange, sequenceLength);
+		flippedInnerRange.should.deep.equal({
+			start: 5,
+			end:3
+		})
+	});
+
+	it('inner fully spans outer, does not wrap origin', function () {
+		const innerRange ={
+			start: 1,
+			end: 7
+		};
+		const outerRange = {
+			start: 2,
+			end:5
+		};
+		const sequenceLength = 10;
+		const flippedInnerRange = flipContainedRange(innerRange, outerRange, sequenceLength);
+		flippedInnerRange.should.deep.equal({
+			start: 0,
+			end:6
+		})
+	});
+
+	it('inner fully spans outer, does wrap origin', function () {
+		const innerRange ={
+			start: 4,
+			end: 2
+		};
+		const outerRange = {
+			start: 5,
+			end:2
+		};
+		const sequenceLength = 10;
+		const flippedInnerRange = flipContainedRange(innerRange, outerRange, sequenceLength);
+		flippedInnerRange.should.deep.equal({
+			start: 5,
+			end:3
+		})
+	});
+
+});
+

package/src/generateRandomRange.js

@@ -0,0 +1,20 @@
+import normalizePositionByRangeLength from './normalizePositionByRangeLength';
+
+export default function generateRandomRange(minStart, maxEnd, maxLength) {
+	const start = getRandomInt(minStart, maxEnd); 
+	let end;
+	if (maxLength) {
+		end = normalizePositionByRangeLength(getRandomInt(start, start + maxLength), maxEnd)
+	} else {
+		end = getRandomInt(minStart, maxEnd); 
+	}
+	return {
+		start: start,
+		end: end,
+	}
+};
+
+
+function getRandomInt(min, max) {
+    return Math.floor(Math.random() * (max - min)) + min;
+}

package/src/generateRandomRange.test.js

@@ -0,0 +1,24 @@
+import getRangeLength from './getRangeLength';
+import generateRandomRange from './generateRandomRange';
+import chai from 'chai';
+chai.should();
+
+describe('generateRandomRange', function () {
+	it('should generate random ranges between a start and end', function () {
+		for (let i = 0; i < 1000; i++) {
+			const range = generateRandomRange(0,10);
+			range.start.should.be.below(11)
+			range.end.should.be.below(11)
+		}
+	});
+
+	it('should generate random ranges between a start and end and with length less than maxLength', function () {
+		for (let i = 0; i < 1000; i++) {
+			const range = generateRandomRange(0,10,5);
+			const length = getRangeLength(range);
+			if (length > -1) {
+				length.should.be.below(6)
+			}
+		}
+	});
+});

package/src/getAnnotationRangeType.js

@@ -0,0 +1,24 @@
+//function that returns the annotation range type
+export default function getAnnotationRangeType(annotationRange, enclosingRangeType, forward) {
+    if (annotationRange.start === enclosingRangeType.start) {
+        if (annotationRange.end === enclosingRangeType.end) {
+            return 'beginningAndEnd';
+        } else {
+            if (forward) {
+                return 'start';
+            } else {
+                return 'end';
+            }
+        }
+    } else {
+        if (annotationRange.end === enclosingRangeType.end) {
+            if (forward) {
+                return 'end';
+            } else {
+                return 'start';
+            }
+        } else {
+            return 'middle';
+        }
+    }
+};