@teselagen/sequence-utils 0.3.41 → 0.3.42-beta.2

package/src/{filterSequenceString.js → filterSequenceString.ts}

@@ -4,24 +4,44 @@ import {
   ambiguous_rna_letters,
   extended_protein_letters
 } from "./bioData";
+import { isFunction } from "lodash-es";
 
-let allWarnings = [];
+let allWarnings: string[] = [];
 
 let makeToast = () => {
-  if (typeof window !== "undefined" && window.toastr && allWarnings.length) {
-    window.toastr.warning(uniq(allWarnings).join("\n"));
+  if (
+    typeof window !== "undefined" &&
+    (window as unknown as { toastr: unknown }).toastr &&
+    allWarnings.length
+  ) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (window as any).toastr.warning(uniq(allWarnings).join("\n"));
   }
   allWarnings = [];
 };
 
-makeToast = debounce(makeToast, 200);
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+(makeToast as any) = debounce(makeToast, 200);
 
-function showWarnings(warnings) {
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function showWarnings(warnings: any) {
   allWarnings = allWarnings.concat(warnings);
-  makeToast.cancel();
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  (makeToast as any).cancel();
   makeToast();
 }
 
+export interface FilterSequenceStringOptions {
+  additionalValidChars?: string;
+  isOligo?: boolean;
+  name?: string;
+  isProtein?: boolean;
+  isRna?: boolean;
+  getAcceptedInsertChars?: (options: FilterSequenceStringOptions) => string;
+  isMixedRnaAndDna?: boolean;
+  [key: string]: unknown;
+}
+
 export default function filterSequenceString(
   sequenceString = "",
   {
@@ -30,15 +50,23 @@ export default function filterSequenceString(
     name,
     isProtein,
     isRna,
+    getAcceptedInsertChars,
     isMixedRnaAndDna
-  } = {}
-) {
-  const acceptedChars = getAcceptedChars({
-    isOligo,
-    isProtein,
-    isRna,
-    isMixedRnaAndDna
-  });
+  }: FilterSequenceStringOptions = {}
+): [string, string[]] {
+  const acceptedChars = isFunction(getAcceptedInsertChars)
+    ? getAcceptedInsertChars({
+        isOligo,
+        isProtein,
+        isRna,
+        isMixedRnaAndDna
+      })
+    : getAcceptedChars({
+        isOligo,
+        isProtein,
+        isRna,
+        isMixedRnaAndDna
+      });
   const replaceChars = getReplaceChars({
     isOligo,
     isProtein,
@@ -47,10 +75,10 @@ export default function filterSequenceString(
   });
 
   let sanitizedVal = "";
-  const invalidChars = [];
+  const invalidChars: string[] = [];
   const chars = `${acceptedChars}${additionalValidChars.split("").join("\\")}`;
-  const warnings = [];
-  const replaceCount = {};
+  const warnings: string[] = [];
+  const replaceCount: Record<string, number> = {};
   sequenceString.split("").forEach(letter => {
     const lowerLetter = letter.toLowerCase();
     if (replaceChars && replaceChars[lowerLetter]) {
@@ -101,7 +129,7 @@ export function getAcceptedChars({
   isProtein,
   isRna,
   isMixedRnaAndDna
-} = {}) {
+}: FilterSequenceStringOptions = {}) {
   return isProtein
     ? `${extended_protein_letters.toLowerCase()}`
     : isOligo
@@ -120,7 +148,7 @@ export function getReplaceChars({
   isProtein,
   isRna,
   isMixedRnaAndDna
-} = {}) {
+}: FilterSequenceStringOptions = {}): Record<string, string> {
   return isProtein
     ? {}
     : // {".": "*"}
@@ -134,5 +162,7 @@ export function getReplaceChars({
             {};
 }
 
-export const filterRnaString = (s, o) =>
-  filterSequenceString(s, { ...o, isRna: true })[0];
+export const filterRnaString = (
+  s: string,
+  o: FilterSequenceStringOptions
+): string => filterSequenceString(s, { ...o, isRna: true })[0];

package/src/{findApproxMatches.js → findApproxMatches.ts}

@@ -7,13 +7,21 @@
  * @param {boolean} circular - Whether to treat the target sequence as circular (default: false)
  * @returns {Array} - Array of objects containing { index, match, mismatchPositions }
  */
+
+export interface ApproxMatch {
+  index: number;
+  match: string;
+  mismatchPositions: number[];
+  numMismatches: number;
+}
+
 export default function findApproxMatches(
-  searchSeq,
-  targetSeq,
-  maxMismatches,
+  searchSeq: string,
+  targetSeq: string,
+  maxMismatches: number,
   circular = false
-) {
-  const matches = [];
+): ApproxMatch[] {
+  const matches: ApproxMatch[] = [];
   const lenA = searchSeq.length;
   const lenB = targetSeq.length;
 
@@ -26,7 +34,7 @@ export default function findApproxMatches(
   for (let i = 0; i < limit; i++) {
     const window = targetSeqExtended.slice(i, i + lenA);
     let mismatchCount = 0;
-    const mismatchPositions = [];
+    const mismatchPositions: number[] = [];
 
     for (let j = 0; j < lenA; j++) {
       if (searchSeq[j] !== window[j]) {

package/src/{findNearestRangeOfSequenceOverlapToPosition.js → findNearestRangeOfSequenceOverlapToPosition.ts}

@@ -1,17 +1,16 @@
-import { normalizeRange } from "@teselagen/range-utils";
+import { normalizeRange, Range } from "@teselagen/range-utils";
 function findNearestRangeOfSequenceOverlapToPosition(
-  sequenceToSearch,
-  overlapSequence,
-  positionStart,
-  isLinear
-) {
-  if (!positionStart) positionStart = 0;
+  sequenceToSearch: string,
+  overlapSequence: string,
+  positionStart = 0,
+  isLinear?: boolean
+): Range | null {
   if (sequenceToSearch.length < overlapSequence.length) {
     return null;
   }
   const regex = new RegExp(overlapSequence, "ig");
-  let result;
-  let index;
+  let result: RegExpExecArray | null;
+  let index: number | undefined;
   let distance = Infinity;
   while (
     (result = regex.exec(sequenceToSearch + (isLinear ? "" : sequenceToSearch)))
@@ -27,6 +26,11 @@ function findNearestRangeOfSequenceOverlapToPosition(
     index = result.index;
     distance = newDistance;
   }
+
+  if (index === undefined) {
+    return null;
+  }
+
   //index is the closest range start
   return normalizeRange(
     {

package/src/{findOrfsInPlasmid.js → findOrfsInPlasmid.ts}

@@ -1,12 +1,12 @@
-import getOrfsFromSequence from "./getOrfsFromSequence.js";
+import getOrfsFromSequence, { Orf } from "./getOrfsFromSequence";
 
 export default function findOrfsInPlasmid(
-  sequence,
-  circular,
-  minimumOrfSize,
-  useAdditionalOrfStartCodons,
-  isProteinOrOligo
-) {
+  sequence: string,
+  circular: boolean,
+  minimumOrfSize: number,
+  useAdditionalOrfStartCodons: boolean,
+  isProteinOrOligo: boolean
+): Orf[] {
   if (isProteinOrOligo) {
     // we do not find ORFs in protein/oligo sequences
     return [];
@@ -27,5 +27,6 @@ export default function findOrfsInPlasmid(
     circular: circular,
     useAdditionalOrfStartCodons
   });
+
   return forwardOrfs.concat(reverseOrfs);
 }

package/src/{findSequenceMatches.js → findSequenceMatches.ts}

@@ -1,6 +1,7 @@
 import {
   modulateRangeBySequenceLength,
-  flipContainedRange
+  flipContainedRange,
+  Range
 } from "@teselagen/range-utils";
 import { reduce, uniqBy } from "lodash-es";
 import escapeStringRegexp from "escape-string-regexp";
@@ -8,11 +9,19 @@ import getAminoAcidStringFromSequenceString from "./getAminoAcidStringFromSequen
 import { ambiguous_dna_values, extended_protein_values } from "./bioData";
 import getReverseComplementSequenceString from "./getReverseComplementSequenceString";
 
+export interface FindSequenceMatchesOptions {
+  searchReverseStrand?: boolean;
+  isCircular?: boolean;
+  isAmbiguous?: boolean;
+  isProteinSequence?: boolean;
+  isProteinSearch?: boolean;
+}
+
 export default function findSequenceMatches(
-  sequence,
-  searchString,
-  options = {}
-) {
+  sequence: string,
+  searchString: string,
+  options: FindSequenceMatchesOptions = {}
+): (Range & { bottomStrand?: boolean })[] {
   let matches = findSequenceMatchesTopStrand(sequence, searchString, options);
   const { searchReverseStrand } = options;
 
@@ -39,7 +48,11 @@ export default function findSequenceMatches(
   return matches;
 }
 
-function findSequenceMatchesTopStrand(sequence, searchString, options = {}) {
+function findSequenceMatchesTopStrand(
+  sequence: string,
+  searchString: string,
+  options: FindSequenceMatchesOptions = {}
+): Range[] {
   const { isCircular, isAmbiguous, isProteinSequence, isProteinSearch } =
     options;
   let searchStringToUse = escapeStringRegexp(searchString);
@@ -51,7 +64,10 @@ function findSequenceMatchesTopStrand(sequence, searchString, options = {}) {
       );
     } else {
       //we're searching DNA
-      searchStringToUse = convertAmbiguousStringToRegex(searchStringToUse);
+      searchStringToUse = convertAmbiguousStringToRegex(
+        searchStringToUse,
+        false
+      );
     }
   }
   if (!searchStringToUse) return []; //short circuit if nothing is actually being searched for (eg searching for "%%"")
@@ -86,11 +102,11 @@ function findSequenceMatchesTopStrand(sequence, searchString, options = {}) {
     ];
   }
 
-  const ranges = [];
+  const ranges: Range[] = [];
   sequencesToCheck.forEach(({ seqToCheck, offset }) => {
     const reg = new RegExp(searchStringToUse, "ig");
-    let match;
-    let range;
+    let match: RegExpExecArray | null;
+    let range: Range;
     /* eslint-disable no-cond-assign*/
 
     while ((match = reg.exec(seqToCheck)) !== null) {
@@ -113,7 +129,7 @@ function findSequenceMatchesTopStrand(sequence, searchString, options = {}) {
   });
 }
 
-function convertAmbiguousStringToRegex(string, isProtein) {
+function convertAmbiguousStringToRegex(string: string, isProtein: boolean) {
   // Search for a DNA subseq in sequence.
   // use ambiguous values (like N = A or T or C or G, R = A or G etc.)
   // searches only on forward strand
@@ -121,8 +137,10 @@ function convertAmbiguousStringToRegex(string, isProtein) {
     string,
     (acc, char) => {
       const value = isProtein
-        ? extended_protein_values[char.toUpperCase()]
-        : ambiguous_dna_values[char.toUpperCase()];
+        ? (extended_protein_values as Record<string, string>)[
+            char.toUpperCase()
+          ]
+        : (ambiguous_dna_values as Record<string, string>)[char.toUpperCase()];
       if (!value) return acc;
       if (value.length === 1) {
         acc += value;

package/src/{generateAnnotations.js → generateAnnotations.ts}

@@ -1,21 +1,26 @@
 import { generateRandomRange } from "@teselagen/range-utils";
 import shortid from "shortid";
+import { Annotation } from "./types";
 
 function generateAnnotations(
-  numberOfAnnotationsToGenerate,
-  start,
-  end,
-  maxLength
-) {
-  const result = {};
+  numberOfAnnotationsToGenerate: number,
+  start: number,
+  end: number,
+  maxLength: number
+): Annotation[] {
+  const result: Annotation[] = [];
   for (let i = 0; i < numberOfAnnotationsToGenerate; i++) {
     const annotation = generateAnnotation(start, end, maxLength);
-    result[annotation.id] = annotation;
+    result.push(annotation);
   }
   return result;
 }
 
-function generateAnnotation(start, end, maxLength) {
+function generateAnnotation(
+  start: number,
+  end: number,
+  maxLength: number
+): Annotation {
   const range = generateRandomRange(start, end, maxLength);
   return {
     ...range,
@@ -27,7 +32,7 @@ function generateAnnotation(start, end, maxLength) {
   };
 }
 
-function getRandomInt(min, max) {
+function getRandomInt(min: number, max: number): number {
   return Math.floor(Math.random() * (max - min)) + min;
 }
 

package/src/{generateSequenceData.js → generateSequenceData.ts}

@@ -1,8 +1,5 @@
-// this is throwing a weird eslint error
-
-//
-
 import generateAnnotations from "./generateAnnotations";
+import { SequenceData } from "./types";
 
 export default function generateSequenceData({
   isProtein,
@@ -11,19 +8,28 @@ export default function generateSequenceData({
   numParts,
   numPrimers,
   numTranslations
-} = {}) {
-  const proteinSequence = isProtein && generateSequence(sequenceLength, true);
-  const sequence = !isProtein && generateSequence(sequenceLength);
+}: {
+  isProtein?: boolean;
+  sequenceLength?: number;
+  numFeatures?: number;
+  numParts?: number;
+  numPrimers?: number;
+  numTranslations?: number;
+} = {}): SequenceData {
+  const proteinSequence = isProtein
+    ? generateSequence(sequenceLength, true)
+    : "";
+  const sequence = !isProtein ? generateSequence(sequenceLength) : "";
 
   return {
     circular: isProtein ? false : Math.random() > 0.5,
-    name: "p-" + Math.floor(Math.random * 100),
+    name: "p-" + Math.floor(Math.random() * 100),
     description: "",
-    isProtein,
+    isProtein: !!isProtein,
     sequence,
     proteinSequence,
     translations: isProtein
-      ? undefined
+      ? []
       : generateAnnotations(
           numTranslations || 5,
           0,
@@ -37,7 +43,7 @@ export default function generateSequenceData({
       sequenceLength / 3
     ),
     primers: isProtein
-      ? undefined
+      ? []
       : generateAnnotations(numPrimers || 10, 0, sequenceLength - 1, 50),
     parts: generateAnnotations(
       numParts || 10,
@@ -50,9 +56,9 @@ export default function generateSequenceData({
 
 // export default tidyUpSequenceData(exampleData)
 
-function generateSequence(m = 9, isProtein) {
+function generateSequence(m = 9, isProtein?: boolean): string {
   let s = "";
-  const r = isProtein ? "" : "gatc";
+  const r = isProtein ? "ACDEFGHIKLMNPQRSTVWY" : "gatc"; // Added explicit protein string instead of empty string default behavior
   for (let i = 0; i < m; i++) {
     s += r.charAt(Math.floor(Math.random() * r.length));
   }

package/src/{getAllInsertionsInSeqReads.js → getAllInsertionsInSeqReads.ts}

@@ -1,10 +1,27 @@
 // seqReads should be an array of objects [{name, seq, pos, cigar}, {name, seq, pos, cigar}, ...]
-export default function getAllInsertionsInSeqReads(seqReads) {
-  const allInsertionsInSeqReads = [];
+
+export interface SeqRead {
+  name: string;
+  seq: string;
+  pos: number;
+  cigar: string;
+}
+
+export interface InsertionInfo {
+  bpPos: number;
+  number: number;
+}
+
+export default function getAllInsertionsInSeqReads(
+  seqReads: SeqRead[]
+): InsertionInfo[] {
+  const allInsertionsInSeqReads: InsertionInfo[] = [];
   seqReads.forEach(seqRead => {
     // split cigar string at M, D, or I (match, deletion, or insertion), e.g. ["2M", "3I", "39M", "3D"...]
     const splitSeqRead = seqRead.cigar.match(/([0-9]*[MDI])/g);
 
+    if (!splitSeqRead) return;
+
     for (let componentI = 0; componentI < splitSeqRead.length; componentI++) {
       if (splitSeqRead[componentI].slice(-1) === "I") {
         let bpPosOfInsertion = seqRead.pos;

package/src/{getAminoAcidDataForEachBaseOfDna.js → getAminoAcidDataForEachBaseOfDna.ts}

@@ -2,7 +2,8 @@ import {
   translateRange,
   getSequenceWithinRange,
   flipContainedRange,
-  isPositionWithinRange
+  isPositionWithinRange,
+  Range
 } from "@teselagen/range-utils";
 import revComp from "./getReverseComplementSequenceString";
 import getAA from "./getAminoAcidFromSequenceTriplet";
@@ -21,7 +22,11 @@ import proteinAlphabet from "./proteinAlphabet";
  * @property {Number} basesRead The number of bases read
  * @property {Number[]} codonPositions The positions of the codon bases in the sequenceString
  */
-function getNextTriplet(index, sequenceString, exonRange) {
+function getNextTriplet(
+  index: number,
+  sequenceString: string,
+  exonRange: Range[]
+) {
   let triplet = "";
   let internalIndex;
   // Positions of codons relative to the coding sequence start
@@ -29,7 +34,7 @@ function getNextTriplet(index, sequenceString, exonRange) {
   const codonPositions = [];
 
   // A function to check if a base is within an exon
-  const isBaseInExon = baseIndex =>
+  const isBaseInExon = (baseIndex: number) =>
     exonRange.some(r =>
       isPositionWithinRange(baseIndex, r, sequenceString.length, true, false)
     );
@@ -74,10 +79,10 @@ function getNextTriplet(index, sequenceString, exonRange) {
   * @property {Object[]} exonRange Array of ranges of the sequenceString that contains the positions of bases corresponding to exons.
 */
 function getTranslatedSequenceProperties(
-  originalSequenceString,
-  forward,
-  optionalSubrangeRange,
-  isProteinSequence
+  originalSequenceString: string,
+  forward: boolean,
+  optionalSubrangeRange: Range | null,
+  isProteinSequence: boolean
 ) {
   const originalSequenceStringLength = isProteinSequence
     ? originalSequenceString.length * 3
@@ -90,7 +95,7 @@ function getTranslatedSequenceProperties(
     sequenceString = getSequenceWithinRange(
       optionalSubrangeRange,
       originalSequenceString
-    );
+    ) as string;
     translationRange.start = optionalSubrangeRange.start;
     translationRange.end = optionalSubrangeRange.end;
   }
@@ -106,8 +111,8 @@ function getTranslatedSequenceProperties(
   // TODO: what to do with protein if this is true?
   const absoluteExonRange =
     !isProteinSequence &&
-    optionalSubrangeRange &&
-    optionalSubrangeRange.locations
+      optionalSubrangeRange &&
+      optionalSubrangeRange.locations
       ? optionalSubrangeRange.locations
       : [translationRange];
   const exonRange = absoluteExonRange.map(range => {
@@ -148,10 +153,10 @@ function getTranslatedSequenceProperties(
  *
  */
 function positionInCdsToPositionInMainSequence(
-  index,
-  forward,
-  translationRange,
-  mainSequenceLength
+  index: number,
+  forward: boolean,
+  translationRange: Range,
+  mainSequenceLength: number
 ) {
   let outputRange = translateRange(
     { start: index, end: index },
@@ -181,10 +186,10 @@ function positionInCdsToPositionInMainSequence(
       }]
  */
 export default function getAminoAcidDataForEachBaseOfDna(
-  originalSequenceString,
-  forward,
-  optionalSubrangeRange,
-  isProteinSequence
+  originalSequenceString: string,
+  forward: boolean,
+  optionalSubrangeRange: Range | null,
+  isProteinSequence: boolean
 ) {
   if (!originalSequenceString) {
     return [];
@@ -215,7 +220,8 @@ export default function getAminoAcidDataForEachBaseOfDna(
     if (isProteinSequence) {
       codonPositionsInCDS = [0, 1, 2].map(i => index + i);
       basesRead = 3;
-      aminoAcid = proteinAlphabet[sequenceString[index / 3].toUpperCase()];
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      aminoAcid = (proteinAlphabet as any)[sequenceString[index / 3].toUpperCase()];
     } else {
       // Get the triplet of DNA bases
       const {
@@ -241,13 +247,13 @@ export default function getAminoAcidDataForEachBaseOfDna(
     // What should the codon range be if it comprises intron bases?
     const codonRange = forward
       ? {
-          start: absoluteCodonPositions[0],
-          end: absoluteCodonPositions[codonPositionsInCDS.length - 1]
-        }
+        start: absoluteCodonPositions[0],
+        end: absoluteCodonPositions[codonPositionsInCDS.length - 1]
+      }
       : {
-          start: absoluteCodonPositions[codonPositionsInCDS.length - 1],
-          end: absoluteCodonPositions[0]
-        };
+        start: absoluteCodonPositions[codonPositionsInCDS.length - 1],
+        end: absoluteCodonPositions[0]
+      };
 
     // Iterate over the positions read
     let positionInCodon = 0;
@@ -256,11 +262,11 @@ export default function getAminoAcidDataForEachBaseOfDna(
       const sequenceIndex = codonPositionsInCDS.includes(posInCds)
         ? absoluteCodonPositions[codonPositionsInCDS.indexOf(posInCds)]
         : positionInCdsToPositionInMainSequence(
-            posInCds,
-            forward,
-            translationRange,
-            originalSequenceStringLength
-          );
+          posInCds,
+          forward,
+          translationRange,
+          originalSequenceStringLength
+        );
       if (codonPositionsInCDS.includes(posInCds)) {
         aminoAcidDataForEachBaseOfDNA.push({
           aminoAcid,

package/src/{getAminoAcidFromSequenceTriplet.js → getAminoAcidFromSequenceTriplet.ts}

@@ -4,19 +4,24 @@ import degenerateDnaToAminoAcidMap from "./degenerateDnaToAminoAcidMap";
 
 //tnrtodo: expand the threeLetterSequenceStringToAminoAcidMap mappings to include RNA characters.
 //currently stop bps aren't all mapped!
-export default function getAminoAcidFromSequenceTriplet(sequenceString) {
+export default function getAminoAcidFromSequenceTriplet(
+  sequenceString: string
+) {
   sequenceString = sequenceString.toLowerCase();
   if (sequenceString.length !== 3) {
     throw new Error("must pass a string of length 3");
   }
-  const aa = threeLetterSequenceStringToAminoAcidMap[sequenceString];
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const aa = (threeLetterSequenceStringToAminoAcidMap as any)[sequenceString];
   if (aa) {
     return aa;
   }
   const letter =
-    degenerateDnaToAminoAcidMap[
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (degenerateDnaToAminoAcidMap as any)[
       sequenceString.replace("x", "n") //replace x's with n's as those are equivalent dna chars
     ] || "x";
 
-  return proteinAlphabet[letter.toUpperCase()];
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return (proteinAlphabet as any)[letter.toUpperCase()];
 }

package/src/{getAminoAcidStringFromSequenceString.js → getAminoAcidStringFromSequenceString.ts}

@@ -1,16 +1,20 @@
 import getAminoAcidDataForEachBaseOfDna from "./getAminoAcidDataForEachBaseOfDna";
+import { AminoAcidData } from "./types";
 
 export default function getAminoAcidStringFromSequenceString(
-  sequenceString,
-  { doNotExcludeAsterisk } = {}
-) {
+  sequenceString: string,
+  options: { doNotExcludeAsterisk?: boolean } = {}
+): string {
+  const { doNotExcludeAsterisk } = options;
   const aminoAcidsPerBase = getAminoAcidDataForEachBaseOfDna(
     sequenceString,
-    true
+    true,
+    null,
+    false
   );
-  const aaArray = [];
+  const aaArray: string[] = [];
   let aaString = "";
-  aminoAcidsPerBase.forEach((aa, index) => {
+  aminoAcidsPerBase.forEach((aa: AminoAcidData, index: number) => {
     if (!aa.fullCodon) {
       return;
     }
@@ -18,10 +22,13 @@ export default function getAminoAcidStringFromSequenceString(
     if (
       !doNotExcludeAsterisk &&
       index >= aminoAcidsPerBase.length - 3 &&
-      aa.aminoAcid.value === "*"
+      aa.aminoAcid?.value === "*"
     ) {
       return;
     }
+    if (aa.aminoAcidIndex === null || !aa.aminoAcid) {
+      return;
+    }
     aaArray[aa.aminoAcidIndex] = aa.aminoAcid.value;
   });
   aaString = aaArray.join("");