@teselagen/range-utils 0.3.20-beta.1 → 0.3.20

package/src/getSequenceWithinRange.ts

@@ -1,33 +0,0 @@
-import { Range } from "./types";
-
-// overload the function signatures so that TS knows what type to expect back (string or T[])
-export default function getSequenceWithinRange(
-  range: Range,
-  sequence: string
-): string;
-export default function getSequenceWithinRange<T>(
-  range: Range,
-  sequence: T[]
-): T[];
-export default function getSequenceWithinRange<T>(
-  range: Range,
-  sequence: string | T[]
-) {
-  if (range.start < 0 || range.end < 0) {
-    if (typeof sequence === "string") return "";
-    return [];
-  }
-  if (range.start > range.end) {
-    //circular range
-    const subSequence = sequence.slice(range.start, sequence.length);
-    if (typeof subSequence === "string") {
-      return subSequence + sequence.slice(0, range.end + 1);
-    } else {
-      return (subSequence as T[]).concat(
-        sequence.slice(0, range.end + 1) as T[]
-      );
-    }
-  } else {
-    return sequence.slice(range.start, range.end + 1);
-  }
-}

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