@teselagen/range-utils 0.3.14-beta.3 → 0.3.14

package/src/generateRandomRange.ts

@@ -1,26 +0,0 @@
-import normalizePositionByRangeLength from "./normalizePositionByRangeLength";
-
-export default function generateRandomRange(
-  minStart: number,
-  maxEnd: number,
-  maxLength: number
-) {
-  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: number, max: number) {
-  return Math.floor(Math.random() * (max - min)) + min;
-}

package/src/getAnnotationRangeType.ts

@@ -1,30 +0,0 @@
-import { Range } from "./types";
-
-//function that returns the annotation range type
-export default function getAnnotationRangeType(
-  annotationRange: Range,
-  enclosingRangeType: Range,
-  forward: boolean
-) {
-  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";
-    }
-  }
-}

package/src/getEachPositionInRangeAsArray.ts

@@ -1,19 +0,0 @@
-import normalizePositionByRangeLength from "./normalizePositionByRangeLength";
-import getRangeLength from "./getRangeLength";
-import { Range } from "./types";
-
-export default function getEachPositionInRangeAsArray(
-  range: Range,
-  rangeMax: number
-) {
-  const output: number[] = [];
-  const length = getRangeLength(range, rangeMax);
-  if (!(length > 0)) {
-    return output;
-  }
-  for (let i = range.start; i < length + range.start; i++) {
-    const position = normalizePositionByRangeLength(i, rangeMax);
-    output.push(position);
-  }
-  return output;
-}

package/src/getLengthOfOverlappingRegionsBetweenTwoRanges.ts

@@ -1,18 +0,0 @@
-import getRangeLength from "./getRangeLength";
-import getOverlapsOfPotentiallyCircularRanges from "./getOverlapsOfPotentiallyCircularRanges";
-import { Range } from "./types";
-
-export default function getLengthOfOverlappingRegionsBetweenTwoRanges(
-  rangeA: Range,
-  rangeB: Range,
-  maxLength: number
-) {
-  const overlaps = getOverlapsOfPotentiallyCircularRanges(
-    rangeA,
-    rangeB,
-    maxLength
-  );
-  return overlaps.reduce(function (counter, overlap) {
-    return counter + getRangeLength(overlap, maxLength);
-  }, 0);
-}

package/src/getMiddleOfRange.ts

@@ -1,11 +0,0 @@
-import getRangeLength from "./getRangeLength";
-import normalizePositionByRangeLength from "./normalizePositionByRangeLength";
-import { Range } from "./types";
-
-export default function getMiddleOfRange(range: Range, rangeMax: number) {
-  const len = getRangeLength({ start: range.start, end: range.end }, rangeMax);
-  return normalizePositionByRangeLength(
-    range.start + Math.floor(len / 2),
-    rangeMax
-  );
-}

package/src/getOverlapOfNonCircularRanges.ts

@@ -1,41 +0,0 @@
-import { Range } from "./types";
-
-export default function getOverlapOfNonCircularRanges(
-  rangeA: Range,
-  rangeB: Range
-) {
-  if (rangeA.start < rangeB.start) {
-    if (rangeA.end < rangeB.start) {
-      //no overlap
-    } else {
-      if (rangeA.end < rangeB.end) {
-        return {
-          start: rangeB.start,
-          end: rangeA.end
-        };
-      } else {
-        return {
-          start: rangeB.start,
-          end: rangeB.end
-        };
-      }
-    }
-  } else {
-    if (rangeA.start > rangeB.end) {
-      //no overlap
-    } else {
-      if (rangeA.end < rangeB.end) {
-        return {
-          start: rangeA.start,
-          end: rangeA.end
-        };
-      } else {
-        return {
-          start: rangeA.start,
-          end: rangeB.end
-        };
-      }
-    }
-  }
-  return null;
-}

package/src/getOverlapsOfPotentiallyCircularRanges.ts

@@ -1,60 +0,0 @@
-import { flatMap } from "lodash-es";
-import splitRangeIntoTwoPartsIfItIsCircular from "./splitRangeIntoTwoPartsIfItIsCircular";
-import getOverlapOfNonCircularRanges from "./getOverlapOfNonCircularRanges";
-
-//returns an array of the overlaps between two potentially circular ranges
-import { Range } from "./types";
-
-//returns an array of the overlaps between two potentially circular ranges
-export default function getOverlapsOfPotentiallyCircularRanges(
-  rangeA: Range,
-  rangeB: Range,
-  maxRangeLength: number,
-  joinIfPossible = false //by default this fn only returns **non-circular** overlaps, if true it will try to join overlaps split on the origin
-) {
-  const normalizedRangeA = splitRangeIntoTwoPartsIfItIsCircular(
-    rangeA,
-    maxRangeLength
-  );
-  const normalizedRangeB = splitRangeIntoTwoPartsIfItIsCircular(
-    rangeB,
-    maxRangeLength
-  );
-
-  let overlaps: Range[] = [];
-
-  normalizedRangeA.forEach(function (nonCircularRangeA) {
-    normalizedRangeB.forEach(function (nonCircularRangeB) {
-      const overlap = getOverlapOfNonCircularRanges(
-        nonCircularRangeA,
-        nonCircularRangeB
-      );
-      if (overlap) {
-        overlaps.push(overlap);
-      }
-    });
-  });
-  if (
-    joinIfPossible &&
-    normalizedRangeA.length === 2 &&
-    normalizedRangeB.length === 2 &&
-    maxRangeLength
-  ) {
-    //we have 2 circular ranges that will have gotten split on the origin, so we'll manually mend those pieces back together
-    const joinedOverlap: Partial<Range> = {};
-    overlaps = flatMap(overlaps, o => {
-      if (o.start === 0) {
-        joinedOverlap.end = o.end;
-        return [];
-      } else if (o.end === maxRangeLength - 1) {
-        joinedOverlap.start = o.start;
-        return [];
-      }
-      return [o];
-    });
-    if (Object.keys(joinedOverlap).length > 0) {
-      overlaps.push(joinedOverlap as Range);
-    }
-  }
-  return overlaps;
-}

package/src/getPositionFromAngle.ts

@@ -1,12 +0,0 @@
-export default function getPositionFromAngle(
-  angle: number,
-  rangeMax: number,
-  isInBetweenPositions?: boolean
-) {
-  //percent through sequence * rangeMax
-  const unroundedPostion = (angle / Math.PI / 2) * rangeMax;
-  //return either the nearest position, or the nearest "inBetween" postion
-  return isInBetweenPositions
-    ? Math.round(unroundedPostion)
-    : Math.floor(unroundedPostion);
-}

package/src/getRangeAngles.ts

@@ -1,38 +0,0 @@
-import getRangeLength from "./getRangeLength";
-import { Range } from "./types";
-import { RangeAngles } from "./RangeAngles";
-
-export default function getRangeAngles(
-  range: Range,
-  rangeMax: number
-): RangeAngles {
-  const { startAngle, totalAngle, endAngle } = getStartEndAndTotalAngle(
-    range,
-    rangeMax
-  );
-
-  return {
-    startAngle,
-    totalAngle,
-    endAngle,
-    centerAngle: startAngle + totalAngle / 2,
-    locationAngles:
-      range.locations &&
-      range.locations.map((location: Range) => {
-        return getRangeAngles(location, rangeMax);
-      })
-  };
-}
-
-function getStartEndAndTotalAngle(range: Range, rangeMax: number) {
-  const rangeLength = getRangeLength(
-    { start: range.start, end: range.end },
-    rangeMax
-  );
-
-  return {
-    startAngle: 2 * Math.PI * (range.start / rangeMax),
-    totalAngle: (rangeLength / rangeMax) * Math.PI * 2,
-    endAngle: (2 * Math.PI * (range.end + 1)) / rangeMax //use a +1 here because the angle must encompass the end of the annotation
-  };
-}

package/src/getRangeLength.test.ts

@@ -1,30 +0,0 @@
-//0123456789
-//r--------r
-//
-//0123
-//r--r
-//  0
-// 3 1
-//  2
-
-import assert from "assert";
-
-import getRangeLength from "./getRangeLength";
-describe("getRangeLength", function () {
-  it("should return the correct length for ranges that cross the origin", function () {
-    const length = getRangeLength({ start: 9, end: 0 }, 10);
-    assert(length === 2);
-  });
-  it("should return the correct length for ranges that do not cross the origin", function () {
-    const length = getRangeLength({ start: 4, end: 6 }, 10);
-    assert(length === 3);
-  });
-  it("should return the correct length for ranges that overlapSelf", function () {
-    const length = getRangeLength({ start: 4, end: 6, overlapsSelf: true }, 10);
-    assert(length === 13);
-  });
-  it("should return the correct length for ranges that overlapSelf and origin", function () {
-    const length = getRangeLength({ start: 9, end: 1, overlapsSelf: true }, 10);
-    assert(length === 13);
-  });
-});

package/src/getRangeLength.ts

@@ -1,17 +0,0 @@
-import provideInclusiveOptions from "./provideInclusiveOptions";
-import { Range } from "./types";
-
-export default provideInclusiveOptions(getRangeLength);
-
-function getRangeLength(range: Range, rangeMax: number) {
-  let toRet;
-  if (range.end < range.start) {
-    toRet = rangeMax - range.start + range.end + 1;
-  } else {
-    toRet = range.end - range.start + 1;
-  }
-  if (range.overlapsSelf && rangeMax) {
-    toRet += rangeMax;
-  }
-  return toRet;
-}

package/src/getRangesBetweenTwoRanges.ts

@@ -1,42 +0,0 @@
-import { Range } from "./types";
-
-export default function getRangesBetweenTwoRanges(
-  range1: Range,
-  range2: Range
-) {
-  // {
-  //     start: 85,
-  //     end: 92
-  // }
-
-  // {
-  //     start: 130,
-  //     end: 189
-  // }
-
-  // start1 - end2
-
-  // start2 - end1
-
-  const newRanges: Range[] = [];
-  if (
-    !(
-      range1.start > -1 &&
-      range1.end > -1 &&
-      range2.start > -1 &&
-      range2.end > -1
-    )
-  ) {
-    return newRanges;
-  }
-  return [
-    {
-      start: range1.start,
-      end: range2.end
-    },
-    {
-      start: range2.start,
-      end: range1.end
-    }
-  ];
-}

package/src/getSequenceWithinRange.test.ts

@@ -1,47 +0,0 @@
-import getSequenceWithinRange from "./getSequenceWithinRange.js";
-
-import assert from "assert";
-let subseq;
-
-describe("getSequenceWithinRange", function () {
-  it("works with an array (translation amino acids for example) as well", function () {
-    subseq = getSequenceWithinRange({ start: 0, end: 0 }, ["a", "t", "g", "c"]);
-    assert.deepEqual(subseq, ["a"]);
-    subseq = getSequenceWithinRange({ start: 1, end: 1 }, ["a", "t", "g", "c"]);
-    assert.deepEqual(subseq, ["t"]);
-    subseq = getSequenceWithinRange({ start: 1, end: 0 }, ["a", "t", "g", "c"]);
-    assert.deepEqual(subseq, ["t", "g", "c", "a"]);
-  });
-  it("gets a non circular range", function () {
-    subseq = getSequenceWithinRange({ start: 0, end: 0 }, "atgc");
-    assert.equal(subseq, "a");
-    subseq = getSequenceWithinRange({ start: 1, end: 1 }, "atgc");
-    assert.equal(subseq, "t");
-    subseq = getSequenceWithinRange({ start: 0, end: 3 }, "atgc");
-    assert.equal(subseq, "atgc");
-  });
-  it("gets a circular range", function () {
-    subseq = getSequenceWithinRange({ start: 1, end: 0 }, "atgc");
-    assert.deepEqual(subseq, "tgca");
-    subseq = getSequenceWithinRange({ start: 2, end: 1 }, "atgc");
-    assert.deepEqual(subseq, "gcat");
-    subseq = getSequenceWithinRange({ start: 3, end: 0 }, "atgc");
-    assert.deepEqual(subseq, "ca");
-  });
-  it("gets a circular range", function () {
-    subseq = getSequenceWithinRange({ start: 1, end: 0 }, "atgc");
-    assert.deepEqual(subseq, "tgca");
-    subseq = getSequenceWithinRange({ start: 2, end: 1 }, "atgc");
-    assert.deepEqual(subseq, "gcat");
-    subseq = getSequenceWithinRange({ start: 3, end: 0 }, "atgc");
-    assert.deepEqual(subseq, "ca");
-  });
-  it("returns an empty string if the range is invalid", function () {
-    subseq = getSequenceWithinRange({ start: -1, end: 0 }, "atgc");
-    assert.deepEqual(subseq, "");
-    subseq = getSequenceWithinRange({ start: -1, end: -1 }, "atgc");
-    assert.deepEqual(subseq, "");
-    subseq = getSequenceWithinRange({ start: 3, end: -1 }, "atgc");
-    assert.deepEqual(subseq, "");
-  });
-});

package/src/getSequenceWithinRange.ts

@@ -1,24 +0,0 @@
-import { Range } from "./types";
-
-//
-export default function getSequenceWithinRange<T>(
-  range: Range,
-  sequence: string | T[]
-) {
-  // ac.throw([ac.range, ac.oneOfType([ac.array, ac.string])], arguments);
-  if (range.start < 0 || range.end < 0) return "";
-  if (range.start > range.end) {
-    //circular range
-    let subSequence = sequence.slice(range.start, sequence.length);
-    if (typeof subSequence === "string") {
-      subSequence += sequence.slice(0, range.end + 1);
-    } else {
-      subSequence = (subSequence as T[]).concat(
-        sequence.slice(0, range.end + 1) as T[]
-      );
-    }
-    return subSequence;
-  } else {
-    return sequence.slice(range.start, range.end + 1);
-  }
-}

package/src/getShortestDistanceBetweenTwoPositions.test.ts

@@ -1,12 +0,0 @@
-import assert from "assert";
-import getShortestDistanceBetweenTwoPositions from "./getShortestDistanceBetweenTwoPositions";
-describe("getShortestDistanceBetweenTwoPositions", function () {
-  it("should return the correct length for positions that cross the origin", function () {
-    const length = getShortestDistanceBetweenTwoPositions(9, 0, 10);
-    assert(length === 1);
-  });
-  it("should return the correct length for ranges that do not cross the origin", function () {
-    const length = getShortestDistanceBetweenTwoPositions(4, 6, 10);
-    assert(length === 2);
-  });
-});

package/src/getShortestDistanceBetweenTwoPositions.ts

@@ -1,16 +0,0 @@
-export default function getShortestDistanceBetweenTwoPositions(
-  position1: number,
-  position2: number,
-  sequenceLength: number
-) {
-  if (position1 < position2) {
-    const position1Holder = position1;
-    position1 = position2;
-    position2 = position1Holder;
-  }
-  //position 1 is now always >= position 2
-
-  const d1 = position1 - position2;
-  const d2 = sequenceLength - position1 + position2;
-  return Math.min(d1, d2);
-}

package/src/getYOffsetForPotentiallyCircularRange.ts

@@ -1,37 +0,0 @@
-import checkIfPotentiallyCircularRangesOverlap from "./checkIfPotentiallyCircularRangesOverlap";
-import { Range } from "./types";
-
-export default function getYOffsetForPotentiallyCircularRange(
-  range: Range,
-  YOffsetLevelsWithRanges: Range[][],
-  assignYOffsetToRange: boolean
-) {
-  //adjust the yOffset of the range being pushed in by checking its range against other range already in the row
-  let yOffset = 0;
-  //YOffsetLevelsWithRanges is an array of arrays (array of yOffset levels holding arrays of range)
-  //loop through y offset levels starting with the 0 level until an empty one is found and push the range into it. If none are found, add another level.
-  const openYOffsetFound = YOffsetLevelsWithRanges.some(
-    function (rangesAlreadyAddedToYOffset, index) {
-      const rangeBlocked = rangesAlreadyAddedToYOffset.some(
-        function (comparisonRange) {
-          return checkIfPotentiallyCircularRangesOverlap(
-            range,
-            comparisonRange
-          );
-        }
-      );
-      if (!rangeBlocked) {
-        yOffset = index;
-        if (assignYOffsetToRange) range.yOffset = index;
-        rangesAlreadyAddedToYOffset.push(range);
-        return true;
-      }
-      return false;
-    }
-  );
-  if (!openYOffsetFound) {
-    yOffset = YOffsetLevelsWithRanges.length;
-    if (assignYOffsetToRange) range.yOffset = YOffsetLevelsWithRanges.length;
-  }
-  return yOffset;
-}

package/src/getYOffsetsForPotentiallyCircularRanges.test.ts

@@ -1,17 +0,0 @@
-import { expect } from "chai";
-import getYOffsetsForPotentiallyCircularRanges from "./getYOffsetsForPotentiallyCircularRanges.js";
-describe("getYOffsetsForPotentiallyCircularRanges", function () {
-  it("returns correct yOffset for overlapping ranges", function () {
-    const ranges = [
-      { start: 0, end: 10, id: "1" },
-      { start: 5, end: 20, id: "2" },
-      { start: 15, end: 25, id: "3" }
-    ];
-    getYOffsetsForPotentiallyCircularRanges(ranges, false);
-    expect(ranges).to.deep.equal([
-      { start: 0, end: 10, id: "1", yOffset: 0 },
-      { start: 5, end: 20, id: "2", yOffset: 1 },
-      { start: 15, end: 25, id: "3", yOffset: 0 }
-    ]);
-  });
-});

package/src/getYOffsetsForPotentiallyCircularRanges.ts

@@ -1,28 +0,0 @@
-import getYOffsetForPotentiallyCircularRange from "./getYOffsetForPotentiallyCircularRange";
-import { Range } from "./types";
-
-export default function getYOffsetsForPotentiallyCircularRanges(
-  ranges: Range[],
-  assignYOffsetToRange: boolean
-) {
-  //adjust the yOffset of the range being pushed in by checking its range against other ranges already in the row
-  const yOffsets: number[] = [];
-  let maxYOffset = 0;
-  const yOffsetLevels: Range[][] = []; //yOffsetLevels is an array of arrays (array of yOffset levels holding arrays of ranges)
-  ranges.forEach(function (range) {
-    //loop through y offset levels starting with the 0 level until an empty one is found and push the range into it. If none are found, add another level.
-    const yOffset = getYOffsetForPotentiallyCircularRange(
-      range,
-      yOffsetLevels,
-      assignYOffsetToRange
-    );
-    yOffsets.push(yOffset);
-    if (yOffset > maxYOffset) {
-      maxYOffset = yOffset;
-    }
-    range.yOffset = yOffset;
-    if (!yOffsetLevels[yOffset]) yOffsetLevels[yOffset] = [];
-    yOffsetLevels[yOffset].push(range);
-  });
-  return { yOffsets: yOffsets, maxYOffset: maxYOffset };
-}

package/src/getZeroedRangeOverlaps.test.ts

@@ -1,65 +0,0 @@
-import assert from "assert";
-import getZeroedRangeOverlaps from "./getZeroedRangeOverlaps";
-describe("getZeroedRangeOverlaps", function () {
-  it("annotation non-circular, selection non circular ", function () {
-    const res = getZeroedRangeOverlaps(
-      { start: 0, end: 3 },
-      { start: 2, end: 3 },
-      4
-    );
-    assert.deepEqual(res, [{ start: 0, end: 1 }]);
-  });
-  it("annotation non circular, selection circular", function () {
-    //01234
-    //aaaa
-    //s sss
-    const res = getZeroedRangeOverlaps(
-      { start: 0, end: 3 },
-      { start: 2, end: 0 },
-      5
-    );
-    assert.deepEqual(res, [
-      { start: 3, end: 3 },
-      { start: 0, end: 1 }
-    ]);
-  });
-  it("annotation non circular, selection circular 2", function () {
-    //0123
-    //aaaa
-    //ssss
-    const res = getZeroedRangeOverlaps(
-      { start: 0, end: 3 },
-      { start: 2, end: 1 },
-      4
-    );
-    assert.deepEqual(res, [
-      { start: 2, end: 3 },
-      { start: 0, end: 1 }
-    ]);
-  });
-  it("annotation circular, selection fully containing", function () {
-    //01234
-    //aa aa
-    //sssss
-    const res = getZeroedRangeOverlaps(
-      { start: 3, end: 1 },
-      { start: 0, end: 4 },
-      5
-    );
-    assert.deepEqual(res, [{ start: 3, end: 1 }]);
-  });
-  it("annotation circular, selection fully containing 2", function () {
-    //01234
-    //aa aa
-    //sssss
-    const res = getZeroedRangeOverlaps(
-      { start: 3, end: 1 },
-      { start: 1, end: 0 },
-      5
-    );
-    assert.deepEqual(res, [
-      { start: 2, end: 4 },
-      { start: 0, end: 0 }
-    ]);
-  });
-});

package/src/getZeroedRangeOverlaps.ts

@@ -1,33 +0,0 @@
-import { Range } from "./types";
-import getOverlapsOfPotentiallyCircularRanges from "./getOverlapsOfPotentiallyCircularRanges";
-import collapseOverlapsGeneratedFromRangeComparisonIfPossible from "./collapseOverlapsGeneratedFromRangeComparisonIfPossible";
-import zeroSubrangeByContainerRange from "./zeroSubrangeByContainerRange";
-import normalizePositionByRangeLength from "./normalizePositionByRangeLength";
-
-//gets the overlapping sections of two ranges and zeroes them to their first point of intersection!
-export default function getZeroedRangeOverlaps(
-  annotation: Range,
-  selection: Range,
-  sequenceLength: number
-) {
-  const overlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible(
-    getOverlapsOfPotentiallyCircularRanges(
-      annotation,
-      selection,
-      sequenceLength
-    ),
-    sequenceLength,
-    annotation
-  );
-  const zeroedOverlaps = overlaps.map(overlap => {
-    return zeroSubrangeByContainerRange(
-      overlap,
-      {
-        start: selection.start,
-        end: normalizePositionByRangeLength(selection.start - 1, sequenceLength)
-      },
-      sequenceLength
-    );
-  });
-  return zeroedOverlaps;
-}