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

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;
-}

package/src/trimRangeByAnotherRange.ts

@@ -1,103 +0,0 @@
-import getOverlapsOfPotentiallyCircularRanges from "./getOverlapsOfPotentiallyCircularRanges";
-import splitRangeIntoTwoPartsIfItIsCircular from "./splitRangeIntoTwoPartsIfItIsCircular";
-import trimNonCicularRangeByAnotherNonCircularRange from "./trimNonCicularRangeByAnotherNonCircularRange";
-import { extend } from "lodash-es";
-import { Range } from "./types";
-
-/**
- * trims range, but does *not* adjust it
- * returns a new range if there is one, or null, if it is trimmed completely
- * @param  {object} subRange  {start:
- *                                  end:
- *                                  }
- * @param  {object} containerRange {start:
- *                                  end:
- *                                  }
- * @param  {int} sequenceLength
- * @return {object} || null        {start:
- *                                  end:
- *                                  }
- */
-export default function trimRangeByAnotherRange(
-  rangeToBeTrimmed: Range,
-  trimmingRange: Range,
-  sequenceLength: number
-): Range | undefined | null {
-  if (!rangeToBeTrimmed || !trimmingRange) {
-    console.warn("invalid range input");
-    return null; //a null return val means something went wrong with this function
-  }
-  let position;
-  for (position of [
-    rangeToBeTrimmed.start,
-    rangeToBeTrimmed.end,
-    trimmingRange.start,
-    trimmingRange.end
-  ]) {
-    if (position < 0 || (!position && position !== 0)) {
-      console.warn("invalid range input");
-      return null; //a null return val means something went wrong with this function
-    }
-  }
-  //get the overlaps of the ranges
-  const overlaps = getOverlapsOfPotentiallyCircularRanges(
-    rangeToBeTrimmed,
-    trimmingRange,
-    sequenceLength
-  );
-  //split the range to be trimmed into pieces if necessary
-  if (!overlaps.length) {
-    //just return the range to be trimmed
-    return rangeToBeTrimmed;
-  }
-  //and trim both pieces by the already calculated overlaps
-  const splitRangesToBeTrimmed: (Range | undefined | null)[] =
-    splitRangeIntoTwoPartsIfItIsCircular(rangeToBeTrimmed, sequenceLength);
-  splitRangesToBeTrimmed.forEach(function (nonCircularRangeToBeTrimmed, index) {
-    overlaps.forEach(function (overlap) {
-      if (nonCircularRangeToBeTrimmed) {
-        nonCircularRangeToBeTrimmed =
-          trimNonCicularRangeByAnotherNonCircularRange(
-            nonCircularRangeToBeTrimmed,
-            overlap
-          );
-      }
-    });
-    splitRangesToBeTrimmed[index] = nonCircularRangeToBeTrimmed;
-  });
-  //filter out any of the split ranges that have been fully deleted!
-  const outputSplitRanges = splitRangesToBeTrimmed.filter(
-    function (trimmedRange): trimmedRange is Range {
-      if (trimmedRange) {
-        return true;
-      }
-      return false;
-    }
-  );
-
-  let outputTrimmedRange;
-  if (outputSplitRanges.length < 0) {
-    //do nothing to the output trimmed range
-  } else if (outputSplitRanges.length === 1) {
-    outputTrimmedRange = outputSplitRanges[0];
-  } else if (outputSplitRanges.length === 2) {
-    if (outputSplitRanges[0].start < outputSplitRanges[1].start) {
-      outputTrimmedRange = {
-        start: outputSplitRanges[1].start,
-        end: outputSplitRanges[0].end
-      };
-    } else {
-      outputTrimmedRange = {
-        start: outputSplitRanges[0].start,
-        end: outputSplitRanges[1].end
-      };
-    }
-  }
-  if (outputTrimmedRange) {
-    return extend({}, rangeToBeTrimmed, {
-      start: outputTrimmedRange.start,
-      end: outputTrimmedRange.end
-    });
-  }
-  return undefined;
-}

package/src/types.ts

@@ -1,12 +0,0 @@
-export interface Range {
-  start: number;
-  end: number;
-  type?: string;
-  locations?: Range[];
-  overlapsSelf?: boolean;
-  yOffset?: number;
-  aminoAcids?: unknown[];
-  forward?: boolean;
-  notes?: Record<string, unknown> | string;
-  [key: string]: unknown;
-}

package/src/zeroSubrangeByContainerRange.ts

@@ -1,49 +0,0 @@
-//
-// ac.throw([ac.posInt, ac.posInt, ac.bool], arguments);
-import trimRangeByAnotherRange from "./trimRangeByAnotherRange";
-
-import { Range } from "./types";
-
-/**
- * "zeroes" a subrange of a container range by
- * adjusting subRange start and end such that it is as if the container range start = 0.
- * @param  {object} subRange  {start:
- *                                     end:
- *                                     }
- * @param  {object} containerRange {start:
- *                                     end:
- *                                     }
- * @param  {int} sequenceLength
- * @return {object}                {start:
- *                                     end:
- *                                     }
- */
-export default function zeroSubrangeByContainerRange(
-  subRange: Range,
-  containerRange: Range,
-  sequenceLength: number
-) {
-  // ac.throw([ac.range, ac.range, ac.posInt], arguments);
-  //first check to make sure the container range fully contains the subRange
-  const trimmedSubRange = trimRangeByAnotherRange(
-    subRange,
-    containerRange,
-    sequenceLength
-  );
-  if (trimmedSubRange) {
-    throw new Error(
-      "subRange must be fully contained by containerRange! Otherwise this function does not make sense"
-    );
-  }
-  const newSubrange: Range = {
-    start: subRange.start - containerRange.start,
-    end: subRange.end - containerRange.start
-  };
-  if (newSubrange.start < 0) {
-    newSubrange.start += sequenceLength;
-  }
-  if (newSubrange.end < 0) {
-    newSubrange.end += sequenceLength;
-  }
-  return newSubrange;
-}

package/types.d.ts

@@ -1,12 +0,0 @@
-export interface Range {
-    start: number;
-    end: number;
-    type?: string;
-    locations?: Range[];
-    overlapsSelf?: boolean;
-    yOffset?: number;
-    aminoAcids?: unknown[];
-    forward?: boolean;
-    notes?: Record<string, unknown> | string;
-    [key: string]: unknown;
-}