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

package/src/adjustRangeToDeletionOfAnotherRange.ts

@@ -1,57 +0,0 @@
-import { Range } from "./types";
-import splitRangeIntoTwoPartsIfItIsCircular from "./splitRangeIntoTwoPartsIfItIsCircular";
-import trimRangeByAnotherRange from "./trimRangeByAnotherRange";
-
-//takes in two potentially circular ranges and returns the first one trimmed by the second one
-//returns null if no range is left after the trimming
-export default function adjustRangeToDeletionOfAnotherRange(
-  rangeToBeAdjusted: Range,
-  anotherRange: Range,
-  maxLength: number
-) {
-  // ac.throw(ac.range, rangeToBeAdjusted)
-  // ac.throw(ac.range, anotherRange)
-  // ac.throw(ac.posInt, maxLength)
-
-  const trimmedRange = trimRangeByAnotherRange(
-    rangeToBeAdjusted,
-    anotherRange,
-    maxLength
-  );
-  if (!trimmedRange) {
-    return null; // Explicitly return null when range is completely trimmed
-  }
-
-  //if there is a range left after being trimmed, adjust it by the deleted anotherRange
-  //we can make some awesome logical simplifications because we know that the two ranges do not overlap (since we've already trimmed the rangeToBeAdjusted)
-  const nonCircularDeletionRanges = splitRangeIntoTwoPartsIfItIsCircular(
-    anotherRange,
-    maxLength
-  );
-  nonCircularDeletionRanges.forEach(function (nonCircularDeletionRange) {
-    const deletionLength =
-      nonCircularDeletionRange.end - nonCircularDeletionRange.start + 1;
-    if (trimmedRange.start > trimmedRange.end) {
-      //the trimmed range is circular
-      if (nonCircularDeletionRange.start < trimmedRange.end) {
-        trimmedRange.start -= deletionLength;
-        trimmedRange.end -= deletionLength;
-      } else if (nonCircularDeletionRange.start < trimmedRange.start) {
-        trimmedRange.start -= deletionLength;
-      } else {
-        //do nothing
-      }
-    } else {
-      if (nonCircularDeletionRange.start < trimmedRange.start) {
-        trimmedRange.start -= deletionLength;
-        trimmedRange.end -= deletionLength;
-      } else if (nonCircularDeletionRange.start < trimmedRange.end) {
-        trimmedRange.end -= deletionLength;
-      } else {
-        //do nothing
-      }
-    }
-  });
-
-  return trimmedRange;
-}

package/src/adjustRangeToInsert.ts

@@ -1,32 +0,0 @@
-import { assign } from "lodash-es";
-import { Range } from "./types";
-
-export default function adjustRangeToInsert(
-  rangeToBeAdjusted: Range,
-  insertStart: number,
-  insertLength: number
-) {
-  // 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;
-}

package/src/adjustRangeToRotation.ts

@@ -1,23 +0,0 @@
-import { assign } from "lodash-es";
-
-import { Range } from "./types";
-
-export default function adjustRangeToRotation(
-  rangeToBeAdjusted: Range,
-  rotateTo = 0,
-  rangeLength?: number
-) {
-  // ac.throw([ac.range, ac.posInt, ac.posInt], arguments);
-  const mod = (n: number) => (rangeLength ? modulo(n, rangeLength) : n);
-
-  const newRange = assign({}, rangeToBeAdjusted, {
-    start: mod(rangeToBeAdjusted.start - (rotateTo || 0)),
-    end: mod(rangeToBeAdjusted.end - (rotateTo || 0))
-  });
-
-  return newRange;
-}
-
-function modulo(n: number, m: number) {
-  return ((n % m) + m) % m;
-}

package/src/checkIfNonCircularRangesOverlap.ts

@@ -1,35 +0,0 @@
-import { Range } from "./types";
-
-//
-// ac.throw([ac.posInt, ac.posInt, ac.bool], arguments);
-export default function checkIfNonCircularRangesOverlap(
-  range: Range,
-  comparisonRange: Range
-) {
-  // ac.throw([ac.range, ac.range], arguments);
-  if (range.start < comparisonRange.start) {
-    if (range.end < comparisonRange.start) {
-      //----llll
-      //--------cccc
-      //no overlap
-      return false;
-    } else {
-      //----llll
-      //-------cccc
-      //overlap
-      return true;
-    }
-  } else {
-    if (range.start > comparisonRange.end) {
-      //------llll
-      // -cccc
-      //no overlap
-      return false;
-    } else {
-      //-----llll
-      // -cccc
-      //overlap
-      return true;
-    }
-  }
-}

package/src/checkIfPotentiallyCircularRangesOverlap.ts

@@ -1,28 +0,0 @@
-//
-//
-import checkIfNonCircularRangesOverlap from "./checkIfNonCircularRangesOverlap";
-
-import splitRangeIntoTwoPartsIfItIsCircular from "./splitRangeIntoTwoPartsIfItIsCircular";
-import { Range } from "./types";
-// ac.throw([ac.posInt, ac.posInt, ac.bool], arguments);
-
-export default function checkIfPotentiallyCircularRangesOverlap(
-  range: Range,
-  comparisonRange: Range
-) {
-  // ac.throw([ac.range, ac.range], arguments);
-  //split the potentially circular ranges and compare each part for overlap
-  return splitRangeIntoTwoPartsIfItIsCircular(range, Infinity).some(
-    function (splitRange) {
-      return splitRangeIntoTwoPartsIfItIsCircular(
-        comparisonRange,
-        Infinity
-      ).some(function (splitComparisonRange) {
-        return checkIfNonCircularRangesOverlap(
-          splitRange,
-          splitComparisonRange
-        );
-      });
-    }
-  );
-}

package/src/collapseOverlapsGeneratedFromRangeComparisonIfPossible.ts

@@ -1,81 +0,0 @@
-import { Range } from "./types";
-
-//this function is a little confusing, but basically it takes an array of overlaps
-//generated from a range overlaps calculation, and it sews them together if possible
-export default function collapseOverlapsGeneratedFromRangeComparisonIfPossible(
-  overlaps: Range[],
-  sequenceLength: number,
-  optionalOriginalRange?: Range
-): Range[] {
-  const originalRangeLinear =
-    optionalOriginalRange &&
-    optionalOriginalRange.start <= optionalOriginalRange.end;
-  if (overlaps.length === 1 || overlaps.length === 0) {
-    return overlaps;
-  } else if (overlaps.length === 2) {
-    if (
-      overlaps[0].start === 0 &&
-      overlaps[1].end + 1 === sequenceLength &&
-      !originalRangeLinear
-    ) {
-      return [
-        {
-          start: overlaps[1].start,
-          end: overlaps[0].end
-        }
-      ];
-    } else if (
-      overlaps[1].start === 0 &&
-      overlaps[0].end + 1 === sequenceLength &&
-      !originalRangeLinear
-    ) {
-      return [
-        {
-          start: overlaps[0].start,
-          end: overlaps[1].end
-        }
-      ];
-    } else {
-      return overlaps;
-    }
-  } else if (overlaps.length === 3) {
-    const firstOverlap = overlaps[0];
-    const secondOverlap = overlaps[1];
-    const thirdOverlap = overlaps[2];
-    let collapsedOverlaps =
-      collapseOverlapsGeneratedFromRangeComparisonIfPossible(
-        [firstOverlap, secondOverlap],
-        sequenceLength,
-        optionalOriginalRange
-      );
-    if (collapsedOverlaps.length === 1) {
-      collapsedOverlaps.push(thirdOverlap);
-      return collapsedOverlaps;
-    } else {
-      collapsedOverlaps =
-        collapseOverlapsGeneratedFromRangeComparisonIfPossible(
-          [firstOverlap, thirdOverlap],
-          sequenceLength,
-          optionalOriginalRange
-        );
-      if (collapsedOverlaps.length === 1) {
-        collapsedOverlaps.push(secondOverlap);
-        return collapsedOverlaps;
-      } else {
-        collapsedOverlaps =
-          collapseOverlapsGeneratedFromRangeComparisonIfPossible(
-            [secondOverlap, thirdOverlap],
-            sequenceLength,
-            optionalOriginalRange
-          );
-        if (collapsedOverlaps.length === 1) {
-          collapsedOverlaps.push(firstOverlap);
-          return collapsedOverlaps;
-        } else {
-          return overlaps;
-        }
-      }
-    }
-  }
-  return overlaps;
-}

package/src/convertRangeIndices.ts

@@ -1,34 +0,0 @@
-import { assign } from "lodash-es";
-import { Range } from "./types";
-
-interface RangeIndicesOptions {
-  inclusive1BasedStart?: boolean;
-  inclusive1BasedEnd?: boolean;
-}
-
-export default function convertRangeIndices(
-  range: Range,
-  inputType: RangeIndicesOptions = {},
-  outputType: RangeIndicesOptions = {}
-) {
-  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/convertRangeTo0Based.ts

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

package/src/convertRangeTo1Based.ts

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

package/src/doesRangeSpanEntireSequence.ts

@@ -1,12 +0,0 @@
-import getRangeLength from "./getRangeLength";
-import { Range } from "./types";
-
-export default function doesRangeSpanEntireSequence(
-  range: Range,
-  sequenceLength: number
-) {
-  if (getRangeLength(range, sequenceLength) === sequenceLength) {
-    return true;
-  }
-  return false;
-}

package/src/doesRangeSpanOrigin.ts

@@ -1,5 +0,0 @@
-import { Range } from "./types";
-
-export default function doesRangeSpanOrigin(range: Range) {
-  return range.start > range.end;
-}

package/src/expandOrContractCircularRangeToPosition.ts

@@ -1,50 +0,0 @@
-import normalizePositionByRangeLength from "./normalizePositionByRangeLength";
-import { assign } from "lodash-es";
-
-import { Range } from "./types";
-
-export default function expandOrContractCircularRangeToPosition(
-  range: Range,
-  position: number,
-  maxLength: number
-) {
-  // 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.ts

@@ -1,30 +0,0 @@
-import { assign } from "lodash-es";
-
-import { Range } from "./types";
-
-export default function expandOrContractNonCircularRangeToPosition(
-  range: Range,
-  position: number
-) {
-  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.ts

@@ -1,18 +0,0 @@
-import { clone } from "lodash-es";
-import { Range } from "./types";
-import normalizeRange from "./normalizeRange";
-
-export default function expandOrContractRangeByLength(
-  range: Range,
-  shiftBy: number,
-  shiftStart: boolean,
-  sequenceLength: number
-) {
-  const rangeToReturn = clone(range);
-  if (shiftStart) {
-    rangeToReturn.start -= shiftBy;
-  } else {
-    rangeToReturn.end += shiftBy;
-  }
-  return normalizeRange(rangeToReturn, sequenceLength);
-}

package/src/expandOrContractRangeToPosition.ts

@@ -1,16 +0,0 @@
-import expandOrContractCircularRangeToPosition from "./expandOrContractCircularRangeToPosition";
-import expandOrContractNonCircularRangeToPosition from "./expandOrContractNonCircularRangeToPosition";
-
-import { Range } from "./types";
-
-export default function expandOrContractRangeToPosition(
-  range: Range,
-  position: number,
-  maxLength: number
-) {
-  if (range.start > range.end) {
-    return expandOrContractCircularRangeToPosition(range, position, maxLength);
-  } else {
-    return expandOrContractNonCircularRangeToPosition(range, position);
-  }
-}

package/src/flipContainedRange.ts

@@ -1,156 +0,0 @@
-import expandOrContractRangeByLength from "./expandOrContractRangeByLength";
-import isRangeWithinRange from "./isRangeWithinRange";
-import getOverlapsOfPotentiallyCircularRanges from "./getOverlapsOfPotentiallyCircularRanges";
-import translateRange from "./translateRange";
-import getRangeLength from "./getRangeLength";
-
-import { Range } from "./types";
-
-export default function flipRelativeRange(
-  innerRange: Range,
-  outerRange: Range,
-  sequenceLength: number
-) {
-  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: Range,
-  outerRange: Range,
-  sequenceLength: number
-) {
-  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) {
-      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: Range,
-  outerRange: Range,
-  sequenceLength: number
-) {
-  //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: Range,
-  outerRange: Range,
-  sequenceLength: number
-) {
-  //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/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;
-}