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

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

@@ -1,13 +1,16 @@
 import { map } from "lodash-es";
 import { adjustRangeToRotation } from "@teselagen/range-utils";
-import tidyUpSequenceData from "./tidyUpSequenceData";
+import tidyUpSequenceData, {
+  TidyUpSequenceDataOptions
+} from "./tidyUpSequenceData";
 import { modifiableTypes } from "./annotationTypes";
 import rotateBpsToPosition from "./rotateBpsToPosition";
+import { SequenceData, Annotation } from "./types";
 
 export default function rotateSequenceDataToPosition(
-  sequenceData,
-  caretPosition,
-  options
+  sequenceData: SequenceData,
+  caretPosition: number,
+  options: TidyUpSequenceDataOptions = {}
 ) {
   const newSequenceData = tidyUpSequenceData(sequenceData, {
     doNotRemoveInvalidChars: true,
@@ -25,7 +28,7 @@ export default function rotateSequenceDataToPosition(
     //update the annotations:
     //handle the delete if necessary
     newSequenceData[annotationType] = adjustAnnotationsToRotation(
-      newSequenceData[annotationType],
+      newSequenceData[annotationType] as Annotation[],
       caretPosition,
       newSequenceData.sequence.length
     );
@@ -34,9 +37,9 @@ export default function rotateSequenceDataToPosition(
 }
 
 function adjustAnnotationsToRotation(
-  annotationsToBeAdjusted,
-  positionToRotateTo,
-  maxLength
+  annotationsToBeAdjusted: Annotation[],
+  positionToRotateTo: number,
+  maxLength: number
 ) {
   return map(annotationsToBeAdjusted, annotation => {
     return {

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

@@ -1,17 +1,24 @@
 import { modifiableTypes } from "./annotationTypes";
 import adjustAnnotationsToInsert from "./adjustAnnotationsToInsert";
+import { SequenceData } from "./types";
 
 export default function shiftAnnotationsByLen({
   seqData,
   caretPosition,
   insertLength
+}: {
+  seqData: SequenceData;
+  caretPosition: number;
+  insertLength: number;
 }) {
   modifiableTypes.forEach(annotationType => {
     const existingAnnotations = seqData[annotationType];
-    seqData[annotationType] = adjustAnnotationsToInsert(
-      existingAnnotations,
-      caretPosition,
-      insertLength
-    );
+    if (existingAnnotations) {
+      seqData[annotationType] = adjustAnnotationsToInsert(
+        existingAnnotations,
+        caretPosition,
+        insertLength
+      );
+    }
   });
 }

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

@@ -1,6 +1,19 @@
 import proteinAlphabet from "./proteinAlphabet";
 
-const initThreeLetterSequenceStringToAminoAcidMap = {
+const initThreeLetterSequenceStringToAminoAcidMap: Record<
+  string,
+  {
+    value: string;
+    name: string;
+    threeLettersName: string;
+    hydrophobicity?: number;
+    colorByFamily: string;
+    color: string;
+    mass: number;
+    isAmbiguous?: boolean;
+    aliases?: string;
+  }
+> = {
   gct: proteinAlphabet.A,
   gcc: proteinAlphabet.A,
   gca: proteinAlphabet.A,
@@ -107,7 +120,7 @@ const initThreeLetterSequenceStringToAminoAcidMap = {
 };
 
 // IUPAC nucleotide codes (DNA/RNA) with U awareness
-const IUPAC = {
+const IUPAC: Record<string, string[]> = {
   A: ["A"],
   C: ["C"],
   G: ["G"],
@@ -128,26 +141,33 @@ const IUPAC = {
   X: ["A", "C", "G", "T", "U"]
 };
 
-
-function expandAndResolve(threeLetterCodon) {
+function expandAndResolve(threeLetterCodon: string) {
   const chars = threeLetterCodon.toUpperCase().split("");
-  const picks = chars.map((c) => IUPAC[c] || [c]);
+  const picks = chars.map(c => IUPAC[c] || [c]);
 
   let allPossibleThreeLetterCodons = [""];
   for (const set of picks) {
     const next = [];
-    for (const prefix of allPossibleThreeLetterCodons) for (const b of set) next.push(prefix + b);
+    for (const prefix of allPossibleThreeLetterCodons)
+      for (const b of set) next.push(prefix + b);
     allPossibleThreeLetterCodons = next;
   }
   let foundAminoAcid = null;
   for (const codon of allPossibleThreeLetterCodons) {
     const lowerCodon = codon.toLowerCase();
-    const aminoAcidObj = initThreeLetterSequenceStringToAminoAcidMap[lowerCodon] ?? initThreeLetterSequenceStringToAminoAcidMap[lowerCodon.replace(/u/g, "t")] ?? initThreeLetterSequenceStringToAminoAcidMap[lowerCodon.replace(/t/g, "u")];
+    const aminoAcidObj =
+      initThreeLetterSequenceStringToAminoAcidMap[lowerCodon] ??
+      initThreeLetterSequenceStringToAminoAcidMap[
+        lowerCodon.replace(/u/g, "t")
+      ] ??
+      initThreeLetterSequenceStringToAminoAcidMap[
+        lowerCodon.replace(/t/g, "u")
+      ];
     if (aminoAcidObj) {
       if (!foundAminoAcid) {
         foundAminoAcid = aminoAcidObj;
-      } else if (foundAminoAcid.value !== aminoAcidObj.value ) {
-        return null
+      } else if (foundAminoAcid.value !== aminoAcidObj.value) {
+        return null;
       }
     } else {
       return null;

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

@@ -1,9 +1,22 @@
 import { cloneDeep, get, some } from "lodash-es";
 import { getFeatureToColorMap, getFeatureTypes } from "./featureTypesAndColors";
 import shortid from "shortid";
+import { Annotation, SequenceData } from "./types";
+
+export interface TidyUpAnnotationOptions {
+  sequenceData?: Partial<SequenceData>;
+  convertAnnotationsFromAAIndices?: boolean;
+  annotationType?: string;
+  provideNewIdsForAnnotations?: boolean;
+  doNotProvideIdsForAnnotations?: boolean;
+  messages?: string[];
+  mutative?: boolean;
+  allowNonStandardGenbankTypes?: boolean;
+  featureTypes?: string[];
+}
 
 export default function tidyUpAnnotation(
-  _annotation,
+  _annotation: Annotation,
   {
     sequenceData = {},
     convertAnnotationsFromAAIndices,
@@ -14,7 +27,7 @@ export default function tidyUpAnnotation(
     mutative,
     allowNonStandardGenbankTypes,
     featureTypes
-  }
+  }: TidyUpAnnotationOptions
 ) {
   const { size, circular, isProtein } = sequenceData;
   if (!_annotation || typeof _annotation !== "object") {
@@ -70,7 +83,7 @@ export default function tidyUpAnnotation(
   if (
     isProtein ||
     annotation.forward === true ||
-    annotation.forward === "true" ||
+    (annotation.forward as unknown) === "true" ||
     annotation.strand === 1 ||
     annotation.strand === "1" ||
     annotation.strand === "+"
@@ -85,7 +98,9 @@ export default function tidyUpAnnotation(
     !annotation.type ||
     typeof annotation.type !== "string" ||
     !some(featureTypes || getFeatureTypes(), featureType => {
-      if (featureType.toLowerCase() === annotation.type.toLowerCase()) {
+      if (
+        featureType.toLowerCase() === (annotation.type as string).toLowerCase()
+      ) {
         annotation.type = featureType; //this makes sure the annotation.type is being set to the exact value of the accepted featureType
         return true;
       }
@@ -123,7 +138,10 @@ export default function tidyUpAnnotation(
   }
 
   if (!annotation.color) {
-    annotation.color = getFeatureToColorMap()[annotation.type];
+    annotation.color =
+      getFeatureToColorMap()[
+        annotation.type as keyof ReturnType<typeof getFeatureToColorMap>
+      ];
   }
   return annotation;
 }
@@ -136,19 +154,23 @@ function coerceLocation({
   messages,
   circular,
   name
+}: {
+  location: Annotation;
+  convertAnnotationsFromAAIndices?: boolean;
+  size?: number;
+  isProtein?: boolean;
+  messages: string[];
+  circular?: boolean;
+  name?: string;
 }) {
-  location.start = parseInt(location.start, 10);
-  location.end = parseInt(location.end, 10);
+  location.start = parseInt(String(location.start), 10);
+  location.end = parseInt(String(location.end), 10);
 
   if (convertAnnotationsFromAAIndices) {
     location.start = location.start * 3;
     location.end = location.end * 3 + 2;
   }
-  if (
-    location.start < 0 ||
-    !(location.start <= size - 1) ||
-    location.start > size - 1
-  ) {
+  if (size !== undefined && (location.start < 0 || location.start > size - 1)) {
     messages.push(
       "Invalid annotation start: " +
         location.start +
@@ -159,11 +181,7 @@ function coerceLocation({
     ); //setting it to 0 internally, but users will see it as 1
     location.start = Math.max(0, size - (isProtein ? 3 : 1));
   }
-  if (
-    location.end < 0 ||
-    !(location.end <= size - 1) ||
-    location.end > size - 1
-  ) {
+  if (size !== undefined && (location.end < 0 || location.end > size - 1)) {
     messages.push(
       "Invalid annotation end:  " +
         location.end +
@@ -174,7 +192,11 @@ function coerceLocation({
     ); //setting it to 0 internally, but users will see it as 1
     location.end = Math.max(0, size - 1);
   }
-  if (location.start > location.end && circular === false) {
+  if (
+    size !== undefined &&
+    location.start > location.end &&
+    circular === false
+  ) {
     messages.push(
       "Invalid circular annotation detected for " + name + ". end set to 1"
     ); //setting it to 0 internally, but users will see it as 1

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

@@ -4,14 +4,37 @@ import shortid from "shortid";
 import getAminoAcidDataForEachBaseOfDna from "./getAminoAcidDataForEachBaseOfDna";
 import { cloneDeep, flatMap } from "lodash-es";
 import { annotationTypes } from "./annotationTypes";
-import filterSequenceString from "./filterSequenceString";
+import filterSequenceString, {
+  FilterSequenceStringOptions
+} from "./filterSequenceString";
 import tidyUpAnnotation from "./tidyUpAnnotation";
 import getDegenerateDnaStringFromAaString from "./getDegenerateDnaStringFromAAString";
 import { getFeatureTypes } from "./featureTypesAndColors";
 import getAminoAcidStringFromSequenceString from "./getAminoAcidStringFromSequenceString";
 import { expandOrContractRangeByLength } from "@teselagen/range-utils";
 
-export default function tidyUpSequenceData(pSeqData, options = {}) {
+import { SequenceData, Annotation } from "./types";
+
+export interface TidyUpSequenceDataOptions {
+  annotationsAsObjects?: boolean;
+  logMessages?: boolean;
+  doNotRemoveInvalidChars?: boolean;
+  additionalValidChars?: string;
+  noTranslationData?: boolean;
+  getAcceptedInsertChars?: (options: FilterSequenceStringOptions) => string;
+  includeProteinSequence?: boolean;
+  doNotProvideIdsForAnnotations?: boolean;
+  noCdsTranslations?: boolean;
+  convertAnnotationsFromAAIndices?: boolean;
+  topLevelSeqData?: Partial<SequenceData>;
+  allowNonStandardGenbankTypes?: boolean;
+  isMixedRnaAndDna?: boolean;
+}
+
+export default function tidyUpSequenceData(
+  pSeqData: Partial<SequenceData>,
+  options: TidyUpSequenceDataOptions = {}
+) {
   const {
     annotationsAsObjects,
     logMessages,
@@ -22,14 +45,16 @@ export default function tidyUpSequenceData(pSeqData, options = {}) {
     doNotProvideIdsForAnnotations,
     noCdsTranslations,
     convertAnnotationsFromAAIndices,
+    isMixedRnaAndDna,
+    getAcceptedInsertChars,
     topLevelSeqData
   } = options;
-  let seqData = cloneDeep(pSeqData); //sequence is usually immutable, so we clone it and return it
+  let seqData = cloneDeep(pSeqData) as SequenceData; //sequence is usually immutable, so we clone it and return it
   const response = {
     messages: []
   };
   if (!seqData) {
-    seqData = {};
+    seqData = { sequence: "" } as SequenceData;
   }
   if (!seqData.sequence) {
     seqData.sequence = "";
@@ -58,14 +83,19 @@ export default function tidyUpSequenceData(pSeqData, options = {}) {
   if (!doNotRemoveInvalidChars) {
     if (seqData.isProtein) {
       const [newSeq] = filterSequenceString(seqData.proteinSequence, {
+        isMixedRnaAndDna,
+        additionalValidChars,
         ...(topLevelSeqData || seqData),
-        isProtein: true
+        isProtein: true,
+        getAcceptedInsertChars
       });
       seqData.proteinSequence = newSeq;
     } else {
       const [newSeq] = filterSequenceString(seqData.sequence, {
         additionalValidChars,
-        ...(topLevelSeqData || seqData)
+        isMixedRnaAndDna,
+        ...(topLevelSeqData || seqData),
+        getAcceptedInsertChars
       });
       seqData.sequence = newSeq;
     }
@@ -94,10 +124,10 @@ export default function tidyUpSequenceData(pSeqData, options = {}) {
     ? seqData.proteinSize
     : seqData.proteinSequence.length;
   if (
-    seqData.circular === "false" ||
+    seqData.circular === ("false" as unknown) ||
     /* eslint-disable eqeqeq*/
 
-    seqData.circular == -1 ||
+    seqData.circular == (-1 as unknown) ||
     /* eslint-enable eqeqeq*/
     seqData.circular === false ||
     (!seqData.circular && seqData.sequenceTypeCode !== "CIRCULAR_DNA")
@@ -110,26 +140,31 @@ export default function tidyUpSequenceData(pSeqData, options = {}) {
 
   annotationTypes.forEach(annotationType => {
     if (!Array.isArray(seqData[annotationType])) {
-      if (typeof seqData[annotationType] === "object") {
-        seqData[annotationType] = Object.keys(seqData[annotationType]).map(
-          key => {
-            return seqData[annotationType][key];
-          }
-        );
+      if (
+        seqData[annotationType] &&
+        typeof seqData[annotationType] === "object"
+      ) {
+        seqData[annotationType] = Object.keys(
+          seqData[annotationType] as object
+        ).map(key => {
+          return (seqData[annotationType] as Record<string, unknown>)[key];
+        });
       } else {
         seqData[annotationType] = [];
       }
     }
-    seqData[annotationType] = seqData[annotationType].filter(annotation => {
-      return tidyUpAnnotation(annotation, {
-        ...options,
-        featureTypes,
-        sequenceData: seqData,
-        convertAnnotationsFromAAIndices,
-        mutative: true,
-        annotationType
-      });
-    });
+    seqData[annotationType] = (seqData[annotationType] as Annotation[]).filter(
+      annotation => {
+        return tidyUpAnnotation(annotation, {
+          ...options,
+          featureTypes,
+          sequenceData: seqData,
+          convertAnnotationsFromAAIndices,
+          mutative: true,
+          annotationType
+        });
+      }
+    );
   });
 
   if (!noTranslationData) {
@@ -138,7 +173,12 @@ export default function tidyUpSequenceData(pSeqData, options = {}) {
         //filter off cds translations
         return [];
       }
-      const codonStart = translation?.notes?.codon_start?.[0] - 1 || 0;
+      const codonStart =
+        (
+          (translation?.notes as Record<string, unknown>)?.[
+            "codon_start"
+          ] as number[]
+        )?.[0] - 1 || 0;
       const expandedRange = expandOrContractRangeByLength(
         translation,
         -codonStart,
@@ -148,8 +188,9 @@ export default function tidyUpSequenceData(pSeqData, options = {}) {
       if (!expandedRange.aminoAcids && !seqData.noSequence) {
         expandedRange.aminoAcids = getAminoAcidDataForEachBaseOfDna(
           seqData.sequence,
-          expandedRange.forward,
-          expandedRange
+          expandedRange.forward || false,
+          expandedRange,
+          false
         );
       }
       return expandedRange;
@@ -158,19 +199,22 @@ export default function tidyUpSequenceData(pSeqData, options = {}) {
 
   if (annotationsAsObjects) {
     annotationTypes.forEach(name => {
-      seqData[name] = seqData[name].reduce((acc, item) => {
-        let itemId;
-        if (item.id || item.id === 0) {
-          itemId = item.id;
-        } else {
-          itemId = shortid();
-          if (!doNotProvideIdsForAnnotations) {
-            item.id = itemId; //assign the newly created id to the item
+      seqData[name] = (seqData[name] as Annotation[]).reduce(
+        (acc: Record<string, Annotation>, item: Annotation) => {
+          let itemId;
+          if (item.id || item.id === 0) {
+            itemId = item.id;
+          } else {
+            itemId = shortid();
+            if (!doNotProvideIdsForAnnotations) {
+              item.id = itemId; //assign the newly created id to the item
+            }
           }
-        }
-        acc[itemId] = item;
-        return acc;
-      }, {});
+          acc[itemId] = item;
+          return acc;
+        },
+        {}
+      );
     });
   }
   if (logMessages && response.messages.length > 0) {

package/src/types.ts

@@ -0,0 +1,98 @@
+import type { Range } from "@teselagen/range-utils";
+
+export interface Annotation extends Range {
+  id?: string | number;
+  name?: string;
+  forward?: boolean;
+  strand?: number | string;
+  type?: string;
+  color?: string;
+  notes?: Record<string, unknown> | string;
+  annotationTypePlural?: string;
+  translationType?: string;
+  [key: string]: unknown;
+}
+
+export interface SequenceData {
+  id?: string;
+  sequence: string;
+  proteinSequence?: string;
+  circular?: boolean;
+  isProtein?: boolean;
+  isRna?: boolean;
+  size?: number;
+  proteinSize?: number;
+  name?: string;
+  description?: string;
+  features?: Annotation[];
+  parts?: Annotation[];
+  translations?: Annotation[];
+  primers?: Annotation[];
+  cutsites?: Annotation[];
+  orfs?: Annotation[];
+  guides?: Annotation[];
+  noSequence?: boolean;
+  sequenceTypeCode?: string;
+  aminoAcidDataForEachBaseOfDNA?: unknown[];
+  chromatogramData?: ChromatogramData;
+  [key: string]: unknown;
+}
+
+export interface ChromatogramData {
+  baseTraces?: unknown[];
+  baseCalls?: unknown[];
+  qualNums?: unknown[];
+  basePos?: unknown[];
+  [key: string]: unknown;
+}
+
+export interface RestrictionEnzyme {
+  name: string;
+  site: string;
+  forwardRegex: string;
+  reverseRegex: string;
+  topSnipOffset?: number;
+  bottomSnipOffset?: number;
+  cutType?: number; // 0 or 1
+  usForward?: number; // upstream forward
+  usReverse?: number;
+  [key: string]: unknown;
+}
+
+export interface CutSite extends Annotation {
+  topSnipPosition: number | null;
+  bottomSnipPosition: number | null;
+  overhangSize: number;
+  overhangBps?: string;
+  restrictionEnzyme: RestrictionEnzyme;
+  upstreamTopSnip?: number | null;
+  upstreamBottomSnip?: number | null;
+  topSnipBeforeBottom?: boolean;
+  upstreamTopBeforeBottom?: boolean;
+  cutType?: number;
+  cutsTwice?: boolean;
+  recognitionSiteRange?: Range;
+  isOverhangIncludedInFragmentSize?: boolean;
+  [key: string]: unknown;
+}
+
+export interface DigestFragment extends Range {
+  isFormedFromLinearEnd?: boolean;
+  madeFromOneCutsite?: boolean;
+  size: number;
+  cut1: CutSite;
+  cut2: CutSite;
+  id: string;
+  name: string;
+  onFragmentSelect?: () => void;
+  [key: string]: unknown;
+}
+
+export interface AminoAcidData {
+  fullCodon: boolean | null;
+  aminoAcid: { value: string } | null;
+  aminoAcidIndex: number | null;
+  positionInCodon?: number | null;
+  sequenceIndex?: number | null;
+  codonRange?: { start: number; end: number } | null;
+}