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

package/src/index.test.ts

@@ -1,39 +0,0 @@
-import * as src from "./index";
-import fs from "fs";
-
-describe("index.js", () => {
-  it(`should export all functions defined`, () => {
-    return new Promise<void>(resolve => {
-      fs.readdir(__dirname, (err, files) => {
-        let passes = true;
-        files.forEach(file => {
-          if (
-            file.indexOf(".test.js") > -1 ||
-            file.indexOf(".test.ts") > -1 ||
-            file.indexOf("index.js") > -1 ||
-            file.indexOf("types.ts") > -1 ||
-            file.indexOf("RangeAngles.ts") > -1 ||
-            file.indexOf("index.ts") > -1
-          ) {
-            return;
-          }
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          const funcOrObj = (src as any)[file.replace(/\.(ts|js)$/, "")];
-          if (!funcOrObj) {
-            console.info(
-              `Uh oh, it looks like you forgot to export (or explicitly ignore) this file:`,
-              file
-            );
-            passes = false;
-          }
-        });
-        if (!passes) {
-          throw new Error(
-            "Please make sure to export (or ignore) each file! Update index.js to export the file"
-          );
-        }
-        resolve();
-      });
-    });
-  });
-});

package/src/index.ts

@@ -1,53 +0,0 @@
-export { default as adjustRangeToDeletionOfAnotherRange } from "./adjustRangeToDeletionOfAnotherRange";
-export { default as adjustRangeToInsert } from "./adjustRangeToInsert";
-export { default as checkIfNonCircularRangesOverlap } from "./checkIfNonCircularRangesOverlap";
-export { default as checkIfPotentiallyCircularRangesOverlap } from "./checkIfPotentiallyCircularRangesOverlap";
-export { default as collapseOverlapsGeneratedFromRangeComparisonIfPossible } from "./collapseOverlapsGeneratedFromRangeComparisonIfPossible";
-export { default as convertRangeIndices } from "./convertRangeIndices";
-export { default as convertRangeTo0Based } from "./convertRangeTo0Based";
-export { default as convertRangeTo1Based } from "./convertRangeTo1Based";
-export { default as doesRangeSpanEntireSequence } from "./doesRangeSpanEntireSequence";
-export { default as isRangeOrPositionWithinRange } from "./isRangeOrPositionWithinRange";
-export { default as doesRangeSpanOrigin } from "./doesRangeSpanOrigin";
-export { default as expandOrContractCircularRangeToPosition } from "./expandOrContractCircularRangeToPosition";
-export { default as expandOrContractNonCircularRangeToPosition } from "./expandOrContractNonCircularRangeToPosition";
-export { default as expandOrContractRangeByLength } from "./expandOrContractRangeByLength";
-export { default as expandOrContractRangeToPosition } from "./expandOrContractRangeToPosition";
-export { default as flipContainedRange } from "./flipContainedRange";
-export { default as generateRandomRange } from "./generateRandomRange";
-export { default as getAnnotationRangeType } from "./getAnnotationRangeType";
-export { default as getEachPositionInRangeAsArray } from "./getEachPositionInRangeAsArray";
-export { default as getLengthOfOverlappingRegionsBetweenTwoRanges } from "./getLengthOfOverlappingRegionsBetweenTwoRanges";
-export { default as getOverlapOfNonCircularRanges } from "./getOverlapOfNonCircularRanges";
-export { default as getOverlapsOfPotentiallyCircularRanges } from "./getOverlapsOfPotentiallyCircularRanges";
-export { default as getPositionFromAngle } from "./getPositionFromAngle";
-export { default as getRangeAngles } from "./getRangeAngles";
-export { default as getRangeLength } from "./getRangeLength";
-export { default as getMiddleOfRange } from "./getMiddleOfRange";
-export { default as getRangesBetweenTwoRanges } from "./getRangesBetweenTwoRanges";
-export { default as getSequenceWithinRange } from "./getSequenceWithinRange";
-export { default as getShortestDistanceBetweenTwoPositions } from "./getShortestDistanceBetweenTwoPositions";
-export { default as getYOffsetForPotentiallyCircularRange } from "./getYOffsetForPotentiallyCircularRange";
-export { default as getYOffsetsForPotentiallyCircularRanges } from "./getYOffsetsForPotentiallyCircularRanges";
-export { default as invertRange } from "./invertRange";
-export { default as isPositionCloserToRangeStartThanRangeEnd } from "./isPositionCloserToRangeStartThanRangeEnd";
-export { default as isPositionWithinRange } from "./isPositionWithinRange";
-export { default as isRangeWithinRange } from "./isRangeWithinRange";
-export { default as loopEachPositionInRange } from "./loopEachPositionInRange";
-export { default as modulatePositionByRange } from "./modulatePositionByRange";
-export { default as modulateRangeBySequenceLength } from "./modulateRangeBySequenceLength";
-export { default as normalizePositionByRangeLength } from "./normalizePositionByRangeLength";
-export { default as normalizePositionByRangeLength1Based } from "./normalizePositionByRangeLength1Based";
-export { default as normalizeRange } from "./normalizeRange";
-export { default as provideInclusiveOptions } from "./provideInclusiveOptions";
-export { default as reversePositionInRange } from "./reversePositionInRange";
-export { default as splitRangeIntoTwoPartsIfItIsCircular } from "./splitRangeIntoTwoPartsIfItIsCircular";
-export { default as translateRange } from "./translateRange";
-export { default as trimNonCicularRangeByAnotherNonCircularRange } from "./trimNonCicularRangeByAnotherNonCircularRange";
-export { default as trimNumberToFitWithin0ToAnotherNumber } from "./trimNumberToFitWithin0ToAnotherNumber";
-export { default as trimRangeByAnotherRange } from "./trimRangeByAnotherRange";
-export { default as zeroSubrangeByContainerRange } from "./zeroSubrangeByContainerRange";
-export { default as adjustRangeToRotation } from "./adjustRangeToRotation";
-export { default as getZeroedRangeOverlaps } from "./getZeroedRangeOverlaps";
-export { default as trimAnnStartEndToFitSeqLength } from "./trimAnnStartEndToFitSeqLength";
-export * from "./types";

package/src/invertRange.ts

@@ -1,25 +0,0 @@
-import { Range } from "./types";
-
-import normalizePositionByRangeLength from "./normalizePositionByRangeLength";
-import provideInclusiveOptions from "./provideInclusiveOptions";
-export default provideInclusiveOptions(invertRange);
-
-function invertRange(
-  rangeOrCaret: Range | number,
-  rangeMax: number
-): Range | undefined {
-  if (typeof rangeOrCaret !== "number" && rangeOrCaret.start > -1) {
-    const start = rangeOrCaret.end + 1;
-    const end = rangeOrCaret.start - 1;
-    return {
-      start: normalizePositionByRangeLength(start, rangeMax, false),
-      end: normalizePositionByRangeLength(end, rangeMax, false)
-    };
-  } else if (typeof rangeOrCaret === "number" && rangeOrCaret > -1) {
-    return {
-      start: normalizePositionByRangeLength(rangeOrCaret, rangeMax, false),
-      end: normalizePositionByRangeLength(rangeOrCaret - 1, rangeMax, false)
-    };
-  }
-  return undefined;
-}

package/src/isPositionCloserToRangeStartThanRangeEnd.ts

@@ -1,22 +0,0 @@
-//function to calculate whether a position is closer to the range start than the range end
-import getShortestDistanceBetweenTwoPositions from "./getShortestDistanceBetweenTwoPositions";
-
-import { Range } from "./types";
-
-export default function isPositionCloserToRangeStartThanRangeEnd(
-  position: number,
-  range: Range,
-  maxLength: number
-) {
-  const distanceFromStart = getShortestDistanceBetweenTwoPositions(
-    range.start,
-    position,
-    maxLength
-  );
-  const distanceFromEnd = getShortestDistanceBetweenTwoPositions(
-    range.end,
-    position,
-    maxLength
-  );
-  return distanceFromStart <= distanceFromEnd;
-}

package/src/isPositionWithinRange.ts

@@ -1,40 +0,0 @@
-import splitRangeIntoTwoPartsIfItIsCircular from "./splitRangeIntoTwoPartsIfItIsCircular";
-/**
- *
- * @param {*} position //assumed to be a 0 based "caretPosition"
- * @param {*} range //0 based inclusive range
- * @param {*} sequenceLength
- * @param {*} includeEdges - (default false) whether or not to say
- */
-import { Range } from "./types";
-
-/**
- *
- * @param {*} position //assumed to be a 0 based "caretPosition"
- * @param {*} range //0 based inclusive range
- * @param {*} sequenceLength
- * @param {*} includeEdges - (default false) whether or not to say
- */
-function isPositionWithinRange(
-  position: number,
-  range: Range,
-  sequenceLength: number,
-  includeStartEdge?: boolean,
-  includeEndEdge?: boolean
-) {
-  const ranges = splitRangeIntoTwoPartsIfItIsCircular(range, sequenceLength);
-  const positionFits = ranges.some(function (range) {
-    if (includeStartEdge ? position < range.start : position <= range.start) {
-      return false;
-    } else {
-      if (includeEndEdge ? position <= range.end + 1 : position <= range.end) {
-        return true;
-      } else {
-        return false;
-      }
-    }
-  });
-  return positionFits;
-}
-
-export default isPositionWithinRange;

package/src/isRangeOrPositionWithinRange.ts

@@ -1,40 +0,0 @@
-import { isObject } from "lodash-es";
-import isRangeWithinRange from "./isRangeWithinRange";
-import isPositionWithinRange from "./isPositionWithinRange";
-
-import { Range } from "./types";
-
-export default function isRangeOrPositionWithinRange(
-  rangeOrPositionToCheck: Range | number,
-  containingRange: Range,
-  maxLength: number,
-  includeStartEdge?: boolean,
-  includeEndEdge?: boolean
-) {
-  if (
-    rangeOrPositionToCheck === undefined ||
-    rangeOrPositionToCheck === null ||
-    containingRange === undefined ||
-    containingRange === null
-  ) {
-    return false;
-  }
-  if (isObject(rangeOrPositionToCheck)) {
-    if (typeof (rangeOrPositionToCheck as Range).start !== "number") {
-      return false;
-    }
-    return isRangeWithinRange(
-      rangeOrPositionToCheck as Range,
-      containingRange,
-      maxLength
-    );
-  } else {
-    return isPositionWithinRange(
-      rangeOrPositionToCheck,
-      containingRange,
-      maxLength,
-      includeStartEdge,
-      includeEndEdge
-    );
-  }
-}

package/src/isRangeWithinRange.ts

@@ -1,18 +0,0 @@
-//TNR: THIS METHOD ONLY WORKS FOR COMPARING 0-BASED RANGES!!!!!!
-import trimRangeByAnotherRange from "./trimRangeByAnotherRange";
-
-import { Range } from "./types";
-
-export default function isRangeWithinRange(
-  rangeToCheck: Range,
-  containingRange: Range,
-  maxLength: number
-) {
-  const ranges = trimRangeByAnotherRange(
-    rangeToCheck,
-    containingRange,
-    maxLength
-  );
-  if (ranges === null) return false;
-  return !ranges;
-}

package/src/loopEachPositionInRange.ts

@@ -1,11 +0,0 @@
-import { Range } from "./types";
-
-import getEachPositionInRangeAsArray from "./getEachPositionInRangeAsArray";
-
-export default function loopEachPositionInRange(
-  range: Range,
-  rangeMax: number,
-  func: (pos: number) => void
-) {
-  getEachPositionInRangeAsArray(range, rangeMax).map(func);
-}

package/src/modulatePositionByRange.ts

@@ -1,15 +0,0 @@
-import { Range } from "./types";
-
-//this function takes a position that might not fit in a given range and puts it into that range
-export default function modulatePositionByRange(
-  position: number,
-  range: Range
-) {
-  let returnVal = position;
-  if (position < range.start) {
-    returnVal = range.end - (range.start - (position + 1));
-  } else if (position > range.end) {
-    returnVal = range.start + (position - range.end - 1);
-  }
-  return returnVal;
-}

package/src/modulateRangeBySequenceLength.ts

@@ -1,13 +0,0 @@
-import { Range } from "./types";
-
-import normalizePositionByRangeLength from "./normalizePositionByRangeLength";
-import provideInclusiveOptions from "./provideInclusiveOptions";
-import { assign } from "lodash-es";
-export default provideInclusiveOptions(modulateRangeBySequenceLength);
-
-function modulateRangeBySequenceLength(range: Range, seqLen: number) {
-  return assign(range, {
-    start: normalizePositionByRangeLength(range.start, seqLen),
-    end: normalizePositionByRangeLength(range.end, seqLen)
-  });
-}

package/src/normalizePositionByRangeLength.ts

@@ -1,24 +0,0 @@
-//
-// ac.throw([ac.posInt, ac.posInt, ac.bool], arguments);
-export default function normalizePositionByRangeLength(
-  pPosition: number,
-  sequenceLength: number,
-  isInBetweenPositions = false
-) {
-  //isInBetweenPositions refers to:
-  // A T G C
-  // 0 1 2 3    <--  isInBetweenPositions = false is counting the positions themselves
-  //0 1 2 3 4   <--  isInBetweenPositions = true is counting the spaces between positions
-  // ac.throw([ac.number, ac.posInt, ac.bool], arguments);
-  let position = pPosition;
-  if (position < 0) {
-    position += sequenceLength;
-  } else if (position + (isInBetweenPositions ? 0 : 1) > sequenceLength) {
-    position -= sequenceLength;
-  }
-  return position < 0
-    ? 0
-    : position > sequenceLength - (isInBetweenPositions ? 0 : 1)
-      ? sequenceLength - (isInBetweenPositions ? 0 : 1)
-      : position;
-}

package/src/normalizePositionByRangeLength1Based.ts

@@ -1,9 +0,0 @@
-//
-import modulatePositionByRange from "./modulatePositionByRange";
-
-export default function normalizePositionByRangeLength1Based(
-  position: number,
-  sequenceLength: number
-) {
-  return modulatePositionByRange(position, { start: 1, end: sequenceLength });
-}

package/src/normalizeRange.ts

@@ -1,12 +0,0 @@
-//normalize range takes in a range that might be slightly outside of the rangeMax and wraps the start/end as necessary to fit
-import { assign } from "lodash-es";
-
-import normalizePositionByRangeLength from "./normalizePositionByRangeLength";
-import { Range } from "./types";
-
-export default function normalizeRange(range: Range, sequenceLength: number) {
-  return assign({}, range, {
-    start: normalizePositionByRangeLength(range.start, sequenceLength),
-    end: normalizePositionByRangeLength(range.end, sequenceLength)
-  });
-}

package/src/provideInclusiveOptions.ts

@@ -1,79 +0,0 @@
-import { assign } from "lodash-es";
-
-type Options = {
-  inclusive1BasedEnd?: boolean;
-  inclusive1BasedStart?: boolean;
-};
-
-export default function provideInclusiveOptions<
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  T extends (...args: any[]) => any
->(
-  funToWrap: T
-): (
-  ...args: [...Parameters<T>, options?: Options]
-) => ReturnType<T> {
-  return function (
-    this: unknown,
-    ...args: [...Parameters<T>, options?: Options]
-  ): ReturnType<T> {
-    const options = args[args.length - 1] as Options | undefined;
-    if (
-      options &&
-      (options.inclusive1BasedEnd || options.inclusive1BasedStart)
-    ) {
-      args.forEach(function (arg, index) {
-        // cast arg to check for start/end
-        const potentialRange = arg as { start?: number; end?: number } | null;
-        if (
-          potentialRange &&
-          typeof potentialRange.start === "number" &&
-          potentialRange.start > -1 &&
-          options.inclusive1BasedStart
-        ) {
-          args[index] = assign(potentialRange, {
-            start: potentialRange.start - 1
-          });
-        }
-        if (
-          potentialRange &&
-          typeof potentialRange.end === "number" &&
-          potentialRange.end > -1 &&
-          options.inclusive1BasedEnd
-        ) {
-          args[index] = assign(potentialRange, {
-            end: potentialRange.end - 1
-          });
-        }
-      });
-    }
-    // eslint-disable-next-line @typescript-eslint/ban-types
-    let returnVal = (funToWrap as Function).apply(this, args);
-    const potentialReturn = returnVal as {
-      start?: number;
-      end?: number;
-    } | null;
-
-    if (
-      potentialReturn &&
-      typeof potentialReturn.start === "number" &&
-      potentialReturn.start > -1 &&
-      options &&
-      options.inclusive1BasedStart
-    ) {
-      returnVal = assign(potentialReturn, {
-        start: potentialReturn.start + 1
-      });
-    }
-    if (
-      potentialReturn &&
-      typeof potentialReturn.end === "number" &&
-      potentialReturn.end > -1 &&
-      options &&
-      options.inclusive1BasedEnd
-    ) {
-      returnVal = assign(potentialReturn, { end: potentialReturn.end + 1 });
-    }
-    return returnVal as ReturnType<T>;
-  };
-}

package/src/reversePositionInRange.ts

@@ -1,17 +0,0 @@
-//
-export default function reversePositionInRange(
-  position: number,
-  rangeLength: number,
-  isInBetweenPositions: boolean
-) {
-  //isInBetweenPositions refers to:
-  // A T G C
-  // 0 1 2 3    <--  isInBetweenPositions = false is counting the positions themselves
-  //0 1 2 3 4   <--  isInBetweenPositions = true is counting the spaces between positions
-  // ac.throw([
-  //     ac.posInt,
-  //     ac.posInt,
-  //     ac.bool
-  // ], arguments);
-  return rangeLength - position - (isInBetweenPositions ? 0 : 1);
-}

package/src/splitRangeIntoTwoPartsIfItIsCircular.ts

@@ -1,36 +0,0 @@
-import { Range } from "./types";
-
-//
-// ac.throw([ac.posInt, ac.posInt, ac.bool], arguments);
-//takes a potentially circular range and returns an array containing the range split on the origin
-export default function splitRangeIntoTwoPartsIfItIsCircular(
-  range: Range,
-  sequenceLength: number
-) {
-  // ac.throw([ac.range, ac.number], arguments);
-  if (sequenceLength !== 0) {
-    sequenceLength = sequenceLength || Infinity;
-  }
-  const ranges = [];
-  if (range.start > range.end) {
-    //the range is cicular, so we return an array of two ranges
-    ranges.push({
-      start: 0,
-      end: range.end,
-      type: "end"
-    });
-    ranges.push({
-      start: range.start,
-      end: sequenceLength - 1,
-      type: "beginning"
-    });
-  } else {
-    //the range isn't circular, so we just return the range
-    ranges.push({
-      start: range.start,
-      end: range.end,
-      type: "beginningAndEnd"
-    });
-  }
-  return ranges;
-}

package/src/translateRange.ts

@@ -1,21 +0,0 @@
-import { Range } from "./types";
-
-import { assign } from "lodash-es";
-import normalizePositionByRangeLength from "./normalizePositionByRangeLength";
-
-export default function translateRange(
-  rangeToBeAdjusted: Range,
-  translateBy: number,
-  rangeLength: number
-) {
-  return assign({}, rangeToBeAdjusted, {
-    start: normalizePositionByRangeLength(
-      rangeToBeAdjusted.start + translateBy,
-      rangeLength
-    ),
-    end: normalizePositionByRangeLength(
-      rangeToBeAdjusted.end + translateBy,
-      rangeLength
-    )
-  });
-}

package/src/trimAnnStartEndToFitSeqLength.ts

@@ -1,9 +0,0 @@
-export default function trimAnnStartEndToFitSeqLength(
-  annStartOrEnd: number,
-  sequenceLength: number
-) {
-  return Math.max(
-    0,
-    Math.min(annStartOrEnd || 0, Math.max(sequenceLength - 1, 0))
-  );
-}

package/src/trimNonCicularRangeByAnotherNonCircularRange.ts

@@ -1,63 +0,0 @@
-//
-import { Range } from "./types";
-
-//
-export default function trimNonCicularRangeByAnotherNonCircularRange(
-  rangeToBeTrimmed: Range,
-  trimmingRange: Range
-): Range | undefined {
-  // ac.throw([ac.range, ac.range], arguments);
-  let outputTrimmedRange;
-  if (!rangeToBeTrimmed) {
-    return outputTrimmedRange;
-  }
-  if (rangeToBeTrimmed.start < trimmingRange.start) {
-    if (rangeToBeTrimmed.end < trimmingRange.start) {
-      // rrr   <range to be trimmed
-      //    ttt  <trimming range
-      outputTrimmedRange = {
-        start: rangeToBeTrimmed.start,
-        end: rangeToBeTrimmed.end
-      };
-    } else {
-      if (rangeToBeTrimmed.end > trimmingRange.end) {
-        // rrrrrr   <range to be trimmed
-        //   ttt  <trimming range
-        outputTrimmedRange = {
-          start: rangeToBeTrimmed.start,
-          end: rangeToBeTrimmed.end
-        };
-      } else {
-        // rrrrrr   <range to be trimmed
-        //   ttt  <trimming range
-        outputTrimmedRange = {
-          start: rangeToBeTrimmed.start,
-          end: trimmingRange.start - 1
-        };
-      }
-    }
-  } else {
-    if (rangeToBeTrimmed.end <= trimmingRange.end) {
-      //   rrr   <range to be trimmed
-      //  ttttt  <trimming range
-      //fully deleting the range, so do nothing
-    } else {
-      if (rangeToBeTrimmed.start > trimmingRange.end) {
-        //     rrrrrr   <range to be trimmed
-        //  ttt  <trimming range
-        outputTrimmedRange = {
-          end: rangeToBeTrimmed.end,
-          start: rangeToBeTrimmed.start
-        };
-      } else {
-        //    rrrrrr   <range to be trimmed
-        //  ttt  <trimming range
-        outputTrimmedRange = {
-          end: rangeToBeTrimmed.end,
-          start: trimmingRange.end + 1
-        };
-      }
-    }
-  }
-  return outputTrimmedRange;
-}

package/src/trimNumberToFitWithin0ToAnotherNumber.ts

@@ -1,15 +0,0 @@
-//
-// ac.throw([ac.posInt, ac.posInt, ac.bool], arguments);
-export default function trimNumberToFitWithin0ToAnotherNumber(
-  numberToBeTrimmed: number,
-  max: number
-) {
-  // ac.throw([ac.number, ac.number], arguments);
-  if (numberToBeTrimmed < 0) {
-    numberToBeTrimmed = 0;
-  }
-  if (numberToBeTrimmed > max) {
-    numberToBeTrimmed = max;
-  }
-  return numberToBeTrimmed;
-}