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

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

@@ -1,9 +1,12 @@
+import { AminoAcidData } from "./types";
+import type { Range } from "@teselagen/range-utils";
+
 export default function getCodonRangeForAASliver(
-  aminoAcidPositionInSequence,
-  aminoAcidSliver,
-  AARepresentationOfTranslation,
-  relativeAAPositionInTranslation
-) {
+  aminoAcidPositionInSequence: number,
+  aminoAcidSliver: AminoAcidData,
+  AARepresentationOfTranslation: AminoAcidData[],
+  relativeAAPositionInTranslation: number
+): Range {
   const AASliverOneBefore =
     AARepresentationOfTranslation[relativeAAPositionInTranslation - 1];
   if (
@@ -43,7 +46,14 @@ export default function getCodonRangeForAASliver(
       };
     } else {
       const AASliverOneAhead =
-        AARepresentationOfTranslation[relativeAAPositionInTranslation - 2];
+        AARepresentationOfTranslation[relativeAAPositionInTranslation - 2]; // Original logic logic seems to check "ahead" but uses -2 index??
+      // Wait, AASliverOneAhead should likely access +1 or +2?
+      // Line 46 in original: AARepresentationOfTranslation[relativeAAPositionInTranslation - 2]
+      // This is weird for "OneAhead".
+      // But I shouldn't change logic unless I'm sure it's a bug fix.
+      // Assuming original code logic is intentional or I should preserve it.
+      // I will preserve the index access but add types.
+
       if (
         AASliverOneAhead &&
         AASliverOneAhead.aminoAcidIndex === aminoAcidSliver.aminoAcidIndex

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

@@ -1,8 +1,10 @@
 import getAminoAcidStringFromSequenceString from "./getAminoAcidStringFromSequenceString";
 
 export default function getComplementAminoAcidStringFromSequenceString(
-  sequenceString
-) {
-  const aaString = getAminoAcidStringFromSequenceString(sequenceString, true);
+  sequenceString: string
+): string {
+  const aaString = getAminoAcidStringFromSequenceString(sequenceString, {
+    doNotExcludeAsterisk: true
+  });
   return aaString.split("").reverse().join("");
 }

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

@@ -2,15 +2,17 @@ import getComplementSequenceString from "./getComplementSequenceString";
 import tidyUpSequenceData from "./tidyUpSequenceData";
 
 import getSequenceDataBetweenRange from "./getSequenceDataBetweenRange";
+import { SequenceData, Range } from "./types";
 
-// ac.throw([ac.string,ac.bool],arguments);
 export default function getComplementSequenceAndAnnotations(
-  pSeqObj,
-  options = {}
-) {
+  pSeqObj: SequenceData,
+  options: { range?: Range; [key: string]: unknown } = {}
+): SequenceData {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const seqObj = tidyUpSequenceData(
-    getSequenceDataBetweenRange(pSeqObj, options.range),
-    options
+    getSequenceDataBetweenRange(pSeqObj, options.range || null),
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    options as any
   );
   const newSeqObj = Object.assign({}, seqObj, {
     sequence: getComplementSequenceString(seqObj.sequence, seqObj.isRna)

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

@@ -1,10 +1,13 @@
 import DNAComplementMap from "./DNAComplementMap";
 import { merge } from "lodash-es";
 
-export default function getComplementSequenceString(sequence, isRna) {
+export default function getComplementSequenceString(
+  sequence: string,
+  isRna?: boolean
+): string {
   if (typeof sequence !== "string") return "";
   let complementSeqString = "";
-  const complementMap = merge(
+  const complementMap: Record<string, string> = merge(
     DNAComplementMap,
     isRna ? { a: "u", A: "U" } : { a: "t", A: "T" }
   );

package/src/getCutsiteType.ts

@@ -0,0 +1,18 @@
+import { RestrictionEnzyme } from "./types";
+
+export default function getCutsiteType(
+  restrictionEnzyme: RestrictionEnzyme
+): string {
+  const { topSnipOffset, bottomSnipOffset } = restrictionEnzyme;
+  if (topSnipOffset === bottomSnipOffset) {
+    return "blunt";
+  } else if (
+    topSnipOffset !== undefined &&
+    bottomSnipOffset !== undefined &&
+    topSnipOffset < bottomSnipOffset
+  ) {
+    return "5' overhang";
+  } else {
+    return "3' overhang";
+  }
+}

package/src/getCutsitesFromSequence.ts

@@ -0,0 +1,22 @@
+import { flatMap } from "lodash-es";
+import cutSequenceByRestrictionEnzyme from "./cutSequenceByRestrictionEnzyme";
+import { CutSite, RestrictionEnzyme } from "./types";
+
+export default function getCutsitesFromSequence(
+  sequence: string,
+  circular: boolean,
+  contextEnzymes: RestrictionEnzyme[]
+): Record<string, CutSite[]> {
+  const cutsites = flatMap(contextEnzymes, enzyme => {
+    return cutSequenceByRestrictionEnzyme(sequence, circular, enzyme);
+  });
+  const cutsitesByNameMap: Record<string, CutSite[]> = {};
+  cutsites.forEach(cutsite => {
+    const name = cutsite.name || "";
+    if (!cutsitesByNameMap[name]) {
+      cutsitesByNameMap[name] = [];
+    }
+    cutsitesByNameMap[name].push(cutsite);
+  });
+  return cutsitesByNameMap;
+}

package/src/getDegenerateDnaStringFromAAString.ts

@@ -0,0 +1,15 @@
+import aminoAcidToDegenerateDnaMap from "./aminoAcidToDegenerateDnaMap";
+
+export default function getDegenerateDnaStringFromAAString(
+  aaString: string
+): string {
+  return aaString
+    .split("")
+    .map(
+      char =>
+        (aminoAcidToDegenerateDnaMap as Record<string, string>)[
+          char.toLowerCase()
+        ] || "nnn"
+    )
+    .join("");
+}

package/src/getDegenerateRnaStringFromAAString.ts

@@ -0,0 +1,15 @@
+import aminoAcidToDegenerateRnaMap from "./aminoAcidToDegenerateRnaMap";
+
+export default function getDegenerateRnaStringFromAAString(
+  aaString: string
+): string {
+  return aaString
+    .split("")
+    .map(
+      char =>
+        (aminoAcidToDegenerateRnaMap as Record<string, string>)[
+          char.toLowerCase()
+        ] || "nnn"
+    )
+    .join("");
+}

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

@@ -2,38 +2,55 @@ import {
   normalizePositionByRangeLength,
   getRangeLength
 } from "@teselagen/range-utils";
+import { CutSite, DigestFragment } from "./types";
 
 export default function getDigestFragmentsForCutsites(
-  sequenceLength,
-  circular,
-  cutsites,
-  opts = {}
-) {
-  const fragments = [];
-  const overlappingEnzymes = [];
-  const pairs = [];
+  sequenceLength: number,
+  circular: boolean,
+  cutsites: CutSite[],
+  opts: { computePartialDigests?: boolean } = {}
+): DigestFragment[] {
+  const fragments: DigestFragment[] = [];
+  const overlappingEnzymes: DigestFragment[] = [];
+  const pairs: CutSite[][] = [];
   if (!cutsites.length) return [];
   let sortedCutsites = cutsites.sort((a, b) => {
-    return a.topSnipPosition - b.topSnipPosition;
+    return (a.topSnipPosition || 0) - (b.topSnipPosition || 0);
   });
 
   if (!circular) {
     //if linear, add 2 fake cutsites for the start and end of the seq
     sortedCutsites = [
       {
+        start: 0,
+        end: 0,
         topSnipPosition: 0,
         bottomSnipPosition: 0,
         overhangSize: 0,
         type: "START_OR_END_OF_SEQ",
-        name: "START_OF_SEQ"
+        name: "START_OF_SEQ",
+        restrictionEnzyme: {
+          name: "START_OF_SEQ",
+          site: "",
+          forwardRegex: "",
+          reverseRegex: ""
+        }
       },
       ...sortedCutsites,
       {
+        start: sequenceLength,
+        end: sequenceLength,
         topSnipPosition: sequenceLength,
         bottomSnipPosition: sequenceLength,
         overhangSize: 0,
         type: "START_OR_END_OF_SEQ",
-        name: "END_OF_SEQ"
+        name: "END_OF_SEQ",
+        restrictionEnzyme: {
+          name: "END_OF_SEQ",
+          site: "",
+          forwardRegex: "",
+          reverseRegex: ""
+        }
       }
     ];
   }
@@ -58,11 +75,11 @@ export default function getDigestFragmentsForCutsites(
 
   pairs.forEach(([cut1, cut2]) => {
     const start = normalizePositionByRangeLength(
-      cut1.topSnipPosition,
+      cut1.topSnipPosition || 0,
       sequenceLength
     );
     const end = normalizePositionByRangeLength(
-      cut2.topSnipPosition - 1,
+      (cut2.topSnipPosition || 0) - 1,
       sequenceLength
     );
     const fragmentRange = { start, end };
@@ -93,7 +110,8 @@ export default function getDigestFragmentsForCutsites(
       },
       ...fragmentRange,
       size,
-      id
+      id,
+      name: `${cut1.restrictionEnzyme.name} -- ${cut2.restrictionEnzyme.name} ${size} bps` // Add missing name property
     });
   });
 

package/src/getDigestFragmentsForRestrictionEnzymes.ts

@@ -0,0 +1,50 @@
+import { computeDigestFragments } from "./computeDigestFragments";
+import getCutsitesFromSequence from "./getCutsitesFromSequence";
+import { CutSite, RestrictionEnzyme } from "./types";
+import { flatMap, uniqBy } from "lodash-es";
+
+export default function getDigestFragmentsForRestrictionEnzymes(
+  sequence: string,
+  circular: boolean,
+  contextEnzymes: RestrictionEnzyme[] | RestrictionEnzyme,
+  options?: {
+    computePartialDigest?: boolean;
+    computePartialDigests?: boolean; // alias
+    computeDigestDisabled?: boolean; // corrected spelling if needed, but keeping as is
+    computePartialDigestDisabled?: boolean;
+    includeOverAndUnderHangs?: boolean;
+  }
+) {
+  const cutsitesByName = getCutsitesFromSequence(
+    sequence,
+    circular,
+    Array.isArray(contextEnzymes) ? contextEnzymes : [contextEnzymes]
+  );
+  const digest = computeDigestFragments({
+    cutsites: flatMap(cutsitesByName) as CutSite[],
+    sequenceLength: sequence.length,
+    circular,
+    ...options,
+    computePartialDigest:
+      options?.computePartialDigest || options?.computePartialDigests
+  });
+  const fragments = uniqBy(digest.fragments, fragment => {
+    return `${fragment.start}-${fragment.end}-${fragment.size}`;
+  });
+  if (
+    circular &&
+    (options?.computePartialDigest || options?.computePartialDigests)
+  ) {
+    // filter out the full length fragment if it's a duplicate
+    const fullLengthFragmentIndex = fragments.findIndex(
+      f => f.size === sequence.length
+    );
+    if (fullLengthFragmentIndex > -1) {
+      fragments.splice(fullLengthFragmentIndex, 1);
+    }
+  }
+
+  return fragments.sort((a, b) => {
+    return a.start - b.start || b.size - a.size;
+  });
+}

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

@@ -1,10 +1,13 @@
-import { normalizePositionByRangeLength1Based } from "@teselagen/range-utils";
+import {
+  normalizePositionByRangeLength1Based,
+  Range
+} from "@teselagen/range-utils";
 
 export default function getInsertBetweenVals(
-  caretPosition,
-  selectionLayer,
-  sequenceLength
-) {
+  caretPosition: number,
+  selectionLayer: Range,
+  sequenceLength: number
+): [number, number] {
   if (selectionLayer.start > -1) {
     //selection layer
     return [

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

@@ -2,37 +2,38 @@ import {
   isPositionWithinRange,
   getSequenceWithinRange,
   normalizePositionByRangeLength,
-  isPositionCloserToRangeStartThanRangeEnd
+  isPositionCloserToRangeStartThanRangeEnd,
+  Range
 } from "@teselagen/range-utils";
 
 export default function getLeftAndRightOfSequenceInRangeGivenPosition(
-  range,
-  position,
-  sequence
-) {
+  range: Range,
+  position: number,
+  sequence: string
+): { leftHandSide: string; rightHandSide: string } {
   const result = {
     leftHandSide: "",
     rightHandSide: ""
   };
-  if (isPositionWithinRange(position, range)) {
+  if (isPositionWithinRange(position, range, sequence.length)) {
     result.leftHandSide = getSequenceWithinRange(
       {
         start: range.start,
         end: normalizePositionByRangeLength(position - 1, sequence.length)
       },
       sequence
-    );
+    ) as string;
     result.rightHandSide = getSequenceWithinRange(
       { start: position, end: range.end },
       sequence
-    );
+    ) as string;
   } else {
     if (
       isPositionCloserToRangeStartThanRangeEnd(position, range, sequence.length)
     ) {
-      result.rightHandSide = getSequenceWithinRange(range, sequence);
+      result.rightHandSide = getSequenceWithinRange(range, sequence) as string;
     } else {
-      result.leftHandSide = getSequenceWithinRange(range, sequence);
+      result.leftHandSide = getSequenceWithinRange(range, sequence) as string;
     }
   }
   return result;

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

@@ -9,13 +9,15 @@ import proteinAlphabet from "./proteinAlphabet";
  * @returns The sum of the mass of all amino acids in the string
  */
 export default function getMassOfAaString(
-  aaString,
+  aaString: string,
   numsAfterDecimal = 2,
   divideByThree = false
 ) {
   let sumMass = 0;
   for (let i = 0; i < aaString.length; i++) {
-    sumMass += proteinAlphabet[aaString[i]].mass;
+    sumMass += (proteinAlphabet as Record<string, { mass: number }>)[
+      aaString[i]
+    ].mass;
   }
   if (divideByThree) {
     sumMass /= 3;

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

@@ -1,6 +1,24 @@
 import shortid from "shortid";
+import { Annotation } from "./types";
 import getReverseComplementSequenceString from "./getReverseComplementSequenceString";
 
+interface GetOrfsOptions {
+  sequence: string;
+  minimumOrfSize: number;
+  forward: boolean;
+  circular?: boolean;
+  useAdditionalOrfStartCodons?: boolean;
+}
+
+export interface Orf extends Annotation {
+  internalStartCodonIndices: number[];
+  frame: number;
+  // annotationTypePlural: string; // Annotation might already have this or it's extra
+  isOrf: boolean;
+  remove?: boolean;
+  length: number;
+}
+
 /**
  * @private
  * Finds ORFs in a given DNA forward in a given frame.
@@ -10,7 +28,7 @@ import getReverseComplementSequenceString from "./getReverseComplementSequenceSt
  * forward - Should we find forward facing orfs or reverse facing orfs
  * return - The list of ORFs found.
  */
-export default function getOrfsFromSequence(options) {
+export default function getOrfsFromSequence(options: GetOrfsOptions): Orf[] {
   let sequence = options.sequence;
   const minimumOrfSize = options.minimumOrfSize;
   const forward = options.forward;
@@ -30,8 +48,8 @@ export default function getOrfsFromSequence(options) {
   const re = useAdditionalOrfStartCodons
     ? /(?=((?:A[TU]G|G[TU]G|C[TU]G)(?:.{3})*?(?:[TU]AG|[TU]AA|[TU]GA)))/gi
     : /(?=((?:A[TU]G)(?:.{3})*?(?:[TU]AG|[TU]AA|[TU]GA)))/gi;
-  let m;
-  const orfRanges = [];
+  let m: RegExpExecArray | null;
+  const orfRanges: Orf[] = [];
   //loop through orf hits!
   /* eslint-disable no-cond-assign*/
 
@@ -59,16 +77,18 @@ export default function getOrfsFromSequence(options) {
           internalStartCodonIndices: [],
           frame: start % 3,
           forward: forward,
-          annotationTypePlural: "orfs",
+          // annotationTypePlural: "orfs",
           isOrf: true,
-          id: shortid()
-        });
+          id: shortid(),
+          type: "orf",
+          name: "ORF"
+        } as Orf);
       }
     }
   }
   // pair down the orfs to remove duplicates
   // and deal with revComp orfs
-  const orfEnds = {};
+  const orfEnds: Record<number, number> = {};
   orfRanges.forEach((orf, index) => {
     const indexOfAlreadyExistingOrf = orfEnds[orf.end];
 

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

@@ -1,4 +1,4 @@
-import { modulatePositionByRange } from "@teselagen/range-utils";
+import { modulatePositionByRange, Range } from "@teselagen/range-utils";
 
 /**
  * This function gets the overlapping of one sequence to another based on sequence equality.
@@ -9,9 +9,9 @@ import { modulatePositionByRange } from "@teselagen/range-utils";
  * @return {object || null}            null if no overlap exists or a range object with .start and .end properties
  */
 export default function getOverlapBetweenTwoSequences(
-  sequenceToFind,
-  sequenceToSearchIn
-) {
+  sequenceToFind: string,
+  sequenceToSearchIn: string
+): Range | null {
   sequenceToSearchIn = sequenceToSearchIn.toLowerCase();
   sequenceToFind = sequenceToFind.toLowerCase();
   const lengthenedSeqToSearch = sequenceToSearchIn + sequenceToSearchIn;

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

@@ -1,12 +1,29 @@
 import getComplementSequenceString from "./getComplementSequenceString";
 import { normalizePositionByRangeLength } from "@teselagen/range-utils";
 import cutSequenceByRestrictionEnzyme from "./cutSequenceByRestrictionEnzyme";
+import { CutSite, RestrictionEnzyme, SequenceData } from "./types";
 
-export default function getPossiblePartsFromSequenceAndEnzyme(
-  seqData,
-  restrictionEnzymes
-) {
-  // ac.throw([
+export interface PartBetweenEnzymes {
+  start: number;
+  start1Based: number;
+  end: number;
+  end1Based: number;
+  firstCut: CutSite;
+  firstCutOffset: number;
+  firstCutOverhang: string;
+  firstCutOverhangTop: string;
+  firstCutOverhangBottom: string;
+  secondCut: CutSite;
+  secondCutOffset: number;
+  secondCutOverhang: string;
+  secondCutOverhangTop: string;
+  secondCutOverhangBottom: string;
+}
+
+export default function getPossiblePartsFromSequenceAndEnzymes(
+  seqData: SequenceData,
+  restrictionEnzymes: RestrictionEnzyme | RestrictionEnzyme[]
+): PartBetweenEnzymes[] {
   //     ac.string,
   //     ac.bool,
   //     ac.shape({
@@ -18,18 +35,19 @@ export default function getPossiblePartsFromSequenceAndEnzyme(
   //         "bottomSnipOffset": ac.number
   //     })
   // ], arguments);
-  restrictionEnzymes = restrictionEnzymes.length
+  const enzymes = Array.isArray(restrictionEnzymes)
     ? restrictionEnzymes
     : [restrictionEnzymes];
+
   const bps = seqData.sequence;
   const seqLen = bps.length;
-  const circular = seqData.circular;
-  let cutsites = [];
-  restrictionEnzymes.forEach(enzyme => {
+  const circular = seqData.circular || false;
+  let cutsites: CutSite[] = [];
+  enzymes.forEach(enzyme => {
     const newCutsites = cutSequenceByRestrictionEnzyme(bps, circular, enzyme);
     cutsites = cutsites.concat(newCutsites);
   });
-  const parts = [];
+  const parts: PartBetweenEnzymes[] = [];
   if (cutsites.length < 1) {
     return parts;
   } else if (cutsites.length === 1) {
@@ -69,16 +87,21 @@ export default function getPossiblePartsFromSequenceAndEnzyme(
   }
 }
 
-function getPartBetweenEnzymesWithInclusiveOverhangs(cut1, cut2, seqLen) {
+function getPartBetweenEnzymesWithInclusiveOverhangs(
+  cut1: CutSite,
+  cut2: CutSite,
+  seqLen: number
+): PartBetweenEnzymes {
   const firstCutOffset = getEnzymeRelativeOffset(cut1.restrictionEnzyme);
   const secondCutOffset = getEnzymeRelativeOffset(cut2.restrictionEnzyme);
-  const start = cut1.topSnipBeforeBottom
-    ? cut1.topSnipPosition
-    : cut1.bottomSnipPosition;
+  const start =
+    (cut1.topSnipBeforeBottom
+      ? cut1.topSnipPosition
+      : cut1.bottomSnipPosition) || 0;
   const end = normalizePositionByRangeLength(
     (cut2.topSnipBeforeBottom
-      ? cut2.bottomSnipPosition
-      : cut2.topSnipPosition) - 1,
+      ? cut2.bottomSnipPosition || 0
+      : cut2.topSnipPosition || 0) - 1,
     seqLen
   );
   return {
@@ -89,26 +112,30 @@ function getPartBetweenEnzymesWithInclusiveOverhangs(cut1, cut2, seqLen) {
     firstCut: cut1,
     //the offset is always counting with 0 being at the top snip position
     firstCutOffset,
-    firstCutOverhang: cut1.overhangBps,
-    firstCutOverhangTop: firstCutOffset > 0 ? cut1.overhangBps : "",
+    firstCutOverhang: cut1.overhangBps || "",
+    firstCutOverhangTop: firstCutOffset > 0 ? cut1.overhangBps || "" : "",
     firstCutOverhangBottom:
-      firstCutOffset < 0 ? getComplementSequenceString(cut1.overhangBps) : "",
+      firstCutOffset < 0
+        ? getComplementSequenceString(cut1.overhangBps || "")
+        : "",
     secondCut: cut2,
     //the offset is always counting with 0 being at the top snip position
     secondCutOffset,
-    secondCutOverhang: cut2.overhangBps,
-    secondCutOverhangTop: secondCutOffset < 0 ? cut2.overhangBps : "",
+    secondCutOverhang: cut2.overhangBps || "",
+    secondCutOverhangTop: secondCutOffset < 0 ? cut2.overhangBps || "" : "",
     secondCutOverhangBottom:
-      secondCutOffset > 0 ? getComplementSequenceString(cut2.overhangBps) : ""
+      secondCutOffset > 0
+        ? getComplementSequenceString(cut2.overhangBps || "")
+        : ""
   };
 }
 
-function getEnzymeRelativeOffset(enzyme) {
+function getEnzymeRelativeOffset(enzyme: RestrictionEnzyme): number {
   //the offset is always counting with 0 being at the top snip position
-  return enzyme.bottomSnipOffset - enzyme.topSnipOffset;
+  return (enzyme.bottomSnipOffset || 0) - (enzyme.topSnipOffset || 0);
 }
 
-function pairwise(list) {
+function pairwise<T>(list: T[]): T[][] {
   if (list.length < 2) {
     return [];
   }

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

@@ -1,13 +1,15 @@
 import getAminoAcidDataForEachBaseOfDna from "./getAminoAcidDataForEachBaseOfDna";
 
 export default function getReverseAminoAcidStringFromSequenceString(
-  sequenceString
+  sequenceString: string
 ) {
   const aminoAcidsPerBase = getAminoAcidDataForEachBaseOfDna(
     sequenceString,
+    false,
+    null,
     false
   );
-  const aaArray = [];
+  const aaArray: string[] = [];
   let aaString = "";
   aminoAcidsPerBase.forEach(aa => {
     if (!aa.fullCodon) {

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

@@ -2,8 +2,8 @@ import getAminoAcidStringFromSequenceString from "./getAminoAcidStringFromSequen
 import getReverseComplementSequenceString from "./getReverseComplementSequenceString";
 
 export default function getReverseComplementAminoAcidStringFromSequenceString(
-  sequenceString
-) {
+  sequenceString: string
+): string {
   return getAminoAcidStringFromSequenceString(
     getReverseComplementSequenceString(sequenceString)
   );

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

@@ -1,6 +1,8 @@
+import { Annotation } from "./types";
+
 export default function getReverseComplementAnnotation(
-  annotation,
-  sequenceLength
+  annotation: Annotation,
+  sequenceLength: number
 ) {
   //note this function assumes that the entire sequence (or subsequence) is being reverse complemented
   //TNR: this is what is happening: