@teselagen/sequence-utils 0.3.37 → 0.3.38-beta.1

package/src/tidyUpAnnotation.ts

@@ -0,0 +1,205 @@
+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,
+  {
+    sequenceData = {},
+    convertAnnotationsFromAAIndices,
+    annotationType,
+    provideNewIdsForAnnotations,
+    doNotProvideIdsForAnnotations,
+    messages = [],
+    mutative,
+    allowNonStandardGenbankTypes,
+    featureTypes
+  }: TidyUpAnnotationOptions
+) {
+  const { size, circular, isProtein } = sequenceData;
+  if (!_annotation || typeof _annotation !== "object") {
+    messages.push("Invalid annotation detected and removed");
+    return false;
+  }
+  let annotation = _annotation;
+  if (!mutative) {
+    annotation = cloneDeep(_annotation);
+  }
+  annotation.annotationTypePlural = annotationType;
+
+  if (!annotation.name || typeof annotation.name !== "string") {
+    messages.push(
+      'Unable to detect valid name for annotation, setting name to "Untitled annotation"'
+    );
+    annotation.name = "Untitled annotation";
+  }
+  if (provideNewIdsForAnnotations) {
+    annotation.id = shortid();
+  }
+  if (!annotation.id && annotation.id !== 0 && !doNotProvideIdsForAnnotations) {
+    annotation.id = shortid();
+    messages.push(
+      "Unable to detect valid ID for annotation, setting ID to " + annotation.id
+    );
+  }
+
+  //run this for the annotation itself
+  coerceLocation({
+    isProtein,
+    location: annotation,
+    convertAnnotationsFromAAIndices,
+    size,
+    messages,
+    circular,
+    name: annotation.name
+  });
+  //and for each location
+  annotation.locations &&
+    annotation.locations.forEach(location => {
+      coerceLocation({
+        isProtein,
+        location,
+        convertAnnotationsFromAAIndices,
+        size,
+        messages,
+        circular,
+        name: annotation.name
+      });
+    });
+
+  if (
+    isProtein ||
+    annotation.forward === true ||
+    (annotation.forward as unknown) === "true" ||
+    annotation.strand === 1 ||
+    annotation.strand === "1" ||
+    annotation.strand === "+"
+  ) {
+    annotation.forward = true;
+    annotation.strand = 1;
+  } else {
+    annotation.forward = false;
+    annotation.strand = -1;
+  }
+  if (
+    !annotation.type ||
+    typeof annotation.type !== "string" ||
+    !some(featureTypes || getFeatureTypes(), featureType => {
+      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;
+      }
+      if (
+        allowNonStandardGenbankTypes ||
+        (typeof window !== "undefined" &&
+          get(window, "tg_allowNonStandardGenbankTypes")) ||
+        (typeof global !== "undefined" &&
+          get(global, "tg_allowNonStandardGenbankTypes"))
+      )
+        return true;
+      return false;
+    })
+  ) {
+    messages.push(
+      "Invalid annotation type detected:  " +
+        annotation.type +
+        " for " +
+        annotation.name +
+        ". set type to misc_feature"
+    );
+    annotation.type = "misc_feature";
+  }
+  if (annotation.notes && typeof annotation.notes === "string") {
+    try {
+      annotation.notes = JSON.parse(annotation.notes);
+    } catch (error) {
+      console.info(
+        `warning 33y00a0912 - couldn't parse notes for ${
+          annotation.name || ""
+        } ${annotation.notes}:`,
+        error
+      );
+    }
+  }
+
+  if (!annotation.color) {
+    annotation.color =
+      getFeatureToColorMap()[
+        annotation.type as keyof ReturnType<typeof getFeatureToColorMap>
+      ];
+  }
+  return annotation;
+}
+
+function coerceLocation({
+  location,
+  convertAnnotationsFromAAIndices,
+  size,
+  isProtein,
+  messages,
+  circular,
+  name
+}: {
+  location: Annotation;
+  convertAnnotationsFromAAIndices?: boolean;
+  size?: number;
+  isProtein?: boolean;
+  messages: string[];
+  circular?: boolean;
+  name?: string;
+}) {
+  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 (size !== undefined && (location.start < 0 || location.start > size - 1)) {
+    messages.push(
+      "Invalid annotation start: " +
+        location.start +
+        " detected for " +
+        location.name +
+        " and set to size: " +
+        size
+    ); //setting it to 0 internally, but users will see it as 1
+    location.start = Math.max(0, size - (isProtein ? 3 : 1));
+  }
+  if (size !== undefined && (location.end < 0 || location.end > size - 1)) {
+    messages.push(
+      "Invalid annotation end:  " +
+        location.end +
+        " detected for " +
+        location.name +
+        " and set to seq size: " +
+        size
+    ); //setting it to 0 internally, but users will see it as 1
+    location.end = Math.max(0, size - 1);
+  }
+  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
+    location.end = size;
+  }
+}

package/src/tidyUpSequenceData.ts

@@ -0,0 +1,213 @@
+// tnrtodo: figure out where to insert this validation exactly..
+import shortid from "shortid";
+
+import getAminoAcidDataForEachBaseOfDna from "./getAminoAcidDataForEachBaseOfDna";
+import { cloneDeep, flatMap } from "lodash-es";
+import { annotationTypes } from "./annotationTypes";
+import filterSequenceString from "./filterSequenceString";
+import tidyUpAnnotation from "./tidyUpAnnotation";
+import getDegenerateDnaStringFromAaString from "./getDegenerateDnaStringFromAAString";
+import { getFeatureTypes } from "./featureTypesAndColors";
+import getAminoAcidStringFromSequenceString from "./getAminoAcidStringFromSequenceString";
+import { expandOrContractRangeByLength } from "@teselagen/range-utils";
+
+import { SequenceData, Annotation } from "./types";
+
+export interface TidyUpSequenceDataOptions {
+  annotationsAsObjects?: boolean;
+  logMessages?: boolean;
+  doNotRemoveInvalidChars?: boolean;
+  additionalValidChars?: string;
+  noTranslationData?: boolean;
+  includeProteinSequence?: boolean;
+  doNotProvideIdsForAnnotations?: boolean;
+  noCdsTranslations?: boolean;
+  convertAnnotationsFromAAIndices?: boolean;
+  topLevelSeqData?: Partial<SequenceData>;
+  allowNonStandardGenbankTypes?: boolean;
+}
+
+export default function tidyUpSequenceData(
+  pSeqData: Partial<SequenceData>,
+  options: TidyUpSequenceDataOptions = {}
+) {
+  const {
+    annotationsAsObjects,
+    logMessages,
+    doNotRemoveInvalidChars,
+    additionalValidChars,
+    noTranslationData,
+    includeProteinSequence,
+    doNotProvideIdsForAnnotations,
+    noCdsTranslations,
+    convertAnnotationsFromAAIndices,
+    topLevelSeqData
+  } = options;
+  let seqData = cloneDeep(pSeqData) as SequenceData; //sequence is usually immutable, so we clone it and return it
+  const response = {
+    messages: []
+  };
+  if (!seqData) {
+    seqData = { sequence: "" } as SequenceData;
+  }
+  if (!seqData.sequence) {
+    seqData.sequence = "";
+  }
+  if (!seqData.proteinSequence) {
+    seqData.proteinSequence = "";
+  }
+  let needsBackTranslation = false;
+  if (seqData.isProtein) {
+    seqData.circular = false; //there are no circular proteins..
+    if (!seqData.proteinSequence && seqData.proteinSequence !== "") {
+      seqData.proteinSequence = seqData.sequence; //if there is no proteinSequence, assign seqData.sequence
+    }
+    if (
+      !seqData.sequence ||
+      seqData.sequence.length !== seqData.proteinSequence.length * 3
+    ) {
+      //if we don't have a sequence or it is clear that the DNA sequence doesn't match the proteinSequence, add a back translation
+      needsBackTranslation = true;
+    }
+  }
+  if (seqData.isRna) {
+    //flip all t's to u's
+    seqData.sequence = seqData.sequence.replace(/t/gi, "u");
+  }
+  if (!doNotRemoveInvalidChars) {
+    if (seqData.isProtein) {
+      const [newSeq] = filterSequenceString(seqData.proteinSequence, {
+        ...(topLevelSeqData || seqData),
+        isProtein: true
+      });
+      seqData.proteinSequence = newSeq;
+    } else {
+      const [newSeq] = filterSequenceString(seqData.sequence, {
+        additionalValidChars,
+        ...(topLevelSeqData || seqData)
+      });
+      seqData.sequence = newSeq;
+    }
+  }
+  if (seqData.isProtein) {
+    if (needsBackTranslation) {
+      //backtranslate the AA sequence
+      seqData.sequence = getDegenerateDnaStringFromAaString(
+        seqData.proteinSequence
+      );
+    }
+    seqData.aminoAcidDataForEachBaseOfDNA = getAminoAcidDataForEachBaseOfDna(
+      seqData.proteinSequence,
+      true,
+      null,
+      true
+    );
+  } else if (includeProteinSequence) {
+    seqData.proteinSequence = getAminoAcidStringFromSequenceString(
+      seqData.sequence
+    );
+  }
+
+  seqData.size = seqData.noSequence ? seqData.size : seqData.sequence.length;
+  seqData.proteinSize = seqData.noSequence
+    ? seqData.proteinSize
+    : seqData.proteinSequence.length;
+  if (
+    seqData.circular === ("false" as unknown) ||
+    /* eslint-disable eqeqeq*/
+
+    seqData.circular == (-1 as unknown) ||
+    /* eslint-enable eqeqeq*/
+    seqData.circular === false ||
+    (!seqData.circular && seqData.sequenceTypeCode !== "CIRCULAR_DNA")
+  ) {
+    seqData.circular = false;
+  } else {
+    seqData.circular = true;
+  }
+  const featureTypes = getFeatureTypes();
+
+  annotationTypes.forEach(annotationType => {
+    if (!Array.isArray(seqData[annotationType])) {
+      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] as Annotation[]).filter(
+      annotation => {
+        return tidyUpAnnotation(annotation, {
+          ...options,
+          featureTypes,
+          sequenceData: seqData,
+          convertAnnotationsFromAAIndices,
+          mutative: true,
+          annotationType
+        });
+      }
+    );
+  });
+
+  if (!noTranslationData) {
+    seqData.translations = flatMap(seqData.translations, translation => {
+      if (noCdsTranslations && translation.translationType === "CDS Feature") {
+        //filter off cds translations
+        return [];
+      }
+      const codonStart =
+        (
+          (translation?.notes as Record<string, unknown>)?.[
+            "codon_start"
+          ] as number[]
+        )?.[0] - 1 || 0;
+      const expandedRange = expandOrContractRangeByLength(
+        translation,
+        -codonStart,
+        true,
+        seqData.sequence.length
+      );
+      if (!expandedRange.aminoAcids && !seqData.noSequence) {
+        expandedRange.aminoAcids = getAminoAcidDataForEachBaseOfDna(
+          seqData.sequence,
+          expandedRange.forward || false,
+          expandedRange,
+          false
+        );
+      }
+      return expandedRange;
+    });
+  }
+
+  if (annotationsAsObjects) {
+    annotationTypes.forEach(name => {
+      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;
+        },
+        {}
+      );
+    });
+  }
+  if (logMessages && response.messages.length > 0) {
+    console.info("tidyUpSequenceData messages:", response.messages);
+  }
+  return seqData;
+}

package/src/types.ts

@@ -0,0 +1,109 @@
+// import { Range } from "@teselagen/range-utils";
+// Temp fix:
+export interface Range {
+  start: number;
+  end: number;
+  type?: string;
+  locations?: Range[];
+  overlapsSelf?: boolean;
+  yOffset?: number;
+  aminoAcids?: unknown[];
+  [key: string]: unknown;
+}
+
+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;
+}