@teselagen/range-utils 0.3.6 → 0.3.8

package/src/flipContainedRange.js

@@ -1,85 +1,146 @@
-import expandOrContractRangeByLength from './expandOrContractRangeByLength';
-import isRangeWithinRange from './isRangeWithinRange';
-import getOverlapsOfPotentiallyCircularRanges from './getOverlapsOfPotentiallyCircularRanges';
-import translateRange from './translateRange';
-import getRangeLength from './getRangeLength';
+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)
-	}
-};
+export default function flipRelativeRange(
+  innerRange,
+  outerRange,
+  sequenceLength
+) {
+  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)
+function flipNonFullyContainedRange(innerRange, outerRange, sequenceLength) {
+  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
+    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) {
+      const firstOverlap = overlaps[0];
+      const 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);
+function flipFullyContainedRange(innerRange, outerRange, sequenceLength) {
+  //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);
+  //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
+  //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);
+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)
-    }
+  return {
+    end: newInnerEnd,
+    start: newInnerEnd - (innerRangeLength - 1)
+  };
 }
 
-
-
-
 //take 2
-

package/src/flipContainedRange.test.js

@@ -1,124 +1,150 @@
 /* eslint-disable no-var*/
-import flipContainedRange from './flipContainedRange';
+import flipContainedRange from "./flipContainedRange";
 
-import chai from 'chai';
+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
-		})
-	});
+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
-		})
-	});
+  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

@@ -1,20 +1,22 @@
-import normalizePositionByRangeLength from './normalizePositionByRangeLength';
+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,
-	}
-};
-
+  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;
+  return Math.floor(Math.random() * (max - min)) + min;
 }

package/src/generateRandomRange.test.js

@@ -1,24 +1,24 @@
-import getRangeLength from './getRangeLength';
-import generateRandomRange from './generateRandomRange';
-import chai from 'chai';
+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)
-		}
-	});
+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)
-			}
-		}
-	});
-});
+  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

@@ -1,24 +1,28 @@
 //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';
-            }
-        }
+export default function getAnnotationRangeType(
+  annotationRange,
+  enclosingRangeType,
+  forward
+) {
+  if (annotationRange.start === enclosingRangeType.start) {
+    if (annotationRange.end === enclosingRangeType.end) {
+      return "beginningAndEnd";
     } else {
-        if (annotationRange.end === enclosingRangeType.end) {
-            if (forward) {
-                return 'end';
-            } else {
-                return 'start';
-            }
-        } else {
-            return 'middle';
-        }
+      if (forward) {
+        return "start";
+      } else {
+        return "end";
+      }
     }
-};
+  } else {
+    if (annotationRange.end === enclosingRangeType.end) {
+      if (forward) {
+        return "end";
+      } else {
+        return "start";
+      }
+    } else {
+      return "middle";
+    }
+  }
+}