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

package/src/aminoAcidToDegenerateDnaMap.ts

@@ -0,0 +1,32 @@
+const aminoAcidToDegenerateDnaMap: Record<string, string> = {
+  "-": "---",
+  ".": "...",
+  "*": "trr",
+  a: "gcn",
+  b: "ray", // D or N => aay + gay = ray
+  c: "tgy",
+  d: "gay",
+  e: "gar",
+  f: "tty",
+  g: "ggn",
+  h: "cay",
+  i: "ath",
+  j: "htn", // L or I ytn + ath => htn
+  k: "aar",
+  l: "ytn", // YTR、CTN => Y=CT, N=AGCT
+  m: "atg",
+  n: "aay",
+  o: "tag", // Pyrrolysine, https://www.ncbi.nlm.nih.gov/pmc/articles/PMC2933860/
+  p: "ccn",
+  q: "car",
+  r: "mgn", // CGN、MGR => M=AC, N=AGCT
+  s: "wsn", // TCN、AGY => AT = w, CG = S, N is AGCT
+  t: "acn",
+  u: "tga", // Selenocysteine, https://www.ncbi.nlm.nih.gov/pmc/articles/PMC2933860/
+  v: "gtn",
+  w: "tgg",
+  x: "nnn", // unknown aa.
+  y: "tay",
+  z: "sar" // E or Q, => gar + car = sar
+};
+export default aminoAcidToDegenerateDnaMap;

package/src/aminoAcidToDegenerateRnaMap.ts

@@ -0,0 +1,32 @@
+const aminoAcidToDegenerateRnaMap = {
+  "-": "---",
+  ".": "...",
+  "*": "trr",
+  a: "gcn",
+  b: "ray",
+  c: "ugy",
+  d: "gay",
+  e: "gar",
+  f: "uuy",
+  g: "ggn",
+  h: "cay",
+  i: "auh",
+  j: "hun",
+  k: "aar",
+  l: "yun",
+  m: "aug",
+  n: "aay",
+  o: "uag",
+  p: "ccn",
+  q: "car",
+  r: "mgn",
+  s: "wsn",
+  t: "acn",
+  u: "uga",
+  v: "gun",
+  w: "ugg",
+  x: "nnn",
+  y: "uay",
+  z: "sar"
+};
+export default aminoAcidToDegenerateRnaMap;

package/src/annotateSingleSeq.ts

@@ -0,0 +1,37 @@
+import { autoAnnotate } from "./autoAnnotate";
+import { SequenceData } from "./types";
+
+function annotateSingleSeq({
+  fullSeq,
+  searchSeq
+}: {
+  fullSeq: SequenceData;
+  searchSeq: SequenceData;
+}) {
+  const fullSeqId = fullSeq.id || "fullSeqId";
+  const searchSeqId = searchSeq.id || "searchSeqId";
+  const results = autoAnnotate({
+    seqsToAnnotateById: {
+      [fullSeqId]: {
+        sequence: fullSeq.sequence,
+        circular: fullSeq.circular,
+        annotations: fullSeq.features || []
+      }
+    },
+    annotationsToCheckById: {
+      [searchSeqId]: {
+        ...searchSeq,
+        id: searchSeqId
+      }
+    },
+    compareName: false
+  });
+  if (results && results[fullSeqId]) {
+    return {
+      matches: results[fullSeqId]
+    };
+  } else {
+    return { matches: [] };
+  }
+}
+export default annotateSingleSeq;

package/src/annotationTypes.ts

@@ -0,0 +1,23 @@
+export const annotationTypes = [
+  "features",
+  "warnings",
+  "assemblyPieces",
+  "lineageAnnotations",
+  "parts",
+  "cutsites",
+  "orfs",
+  "translations",
+  "primers",
+  "guides"
+];
+
+export const modifiableTypes = [
+  "features",
+  "assemblyPieces",
+  "lineageAnnotations",
+  "warnings",
+  "parts",
+  "translations",
+  "primers",
+  "guides"
+];

package/src/autoAnnotate.test.js

@@ -1,4 +1,3 @@
-/* eslint-disable no-unused-expressions */
 import {
   autoAnnotate,
   convertApELikeRegexToRegex,

package/src/autoAnnotate.ts

@@ -0,0 +1,290 @@
+/* Copyright (C) 2018 TeselaGen Biotechnology, Inc. */
+import { forEach, omitBy } from "lodash-es";
+import { ambiguous_dna_values } from "./bioData";
+import aminoAcidToDegenerateDnaMap from "./aminoAcidToDegenerateDnaMap";
+import {
+  normalizePositionByRangeLength,
+  reversePositionInRange
+} from "@teselagen/range-utils";
+import getReverseComplementSequenceString from "./getReverseComplementSequenceString";
+import { Annotation } from "./types";
+
+//seqsToAnnotateById must not be length = 0
+function autoAnnotate({
+  seqsToAnnotateById,
+  annotationsToCheckById,
+  compareName,
+  warnIfMoreThan
+}: {
+  seqsToAnnotateById: Record<
+    string,
+    { sequence: string; annotations: Annotation[]; circular?: boolean }
+  >;
+  annotationsToCheckById: Record<string, { sequence: string; id: string }>;
+  compareName?: boolean;
+  warnIfMoreThan?: number;
+}) {
+  const annotationsToAddBySeqId: Record<string, Annotation[]> = {};
+
+  forEach(annotationsToCheckById, ann => {
+    const reg = new RegExp(ann.sequence, "gi");
+    forEach(
+      omitBy(seqsToAnnotateById, s => !s.sequence.length),
+      ({ circular, sequence }, id) => {
+        function getMatches({
+          seqToMatchAgainst,
+          isReverse,
+          seqLen
+        }: {
+          seqToMatchAgainst: string;
+          isReverse?: boolean;
+          seqLen: number;
+        }) {
+          let match;
+          let lastMatch: { start: number; end: number } | undefined;
+          // const matches = []
+          try {
+            while ((match = reg.exec(seqToMatchAgainst))) {
+              const { index: matchStart, 0: matchSeq } = match;
+              if (matchStart >= seqLen) return;
+              const matchEnd = matchStart + matchSeq.length;
+              if (lastMatch) {
+                if (matchStart > lastMatch.start && matchEnd <= lastMatch.end) {
+                  reg.lastIndex = match.index + 1;
+                  continue;
+                }
+              }
+              lastMatch = {
+                start: matchStart,
+                end: matchEnd
+              };
+              const range = {
+                start: matchStart,
+                end: normalizePositionByRangeLength(matchEnd - 1, seqLen, false)
+              };
+              if (!annotationsToAddBySeqId[id])
+                annotationsToAddBySeqId[id] = [];
+              annotationsToAddBySeqId[id].push({
+                ...(isReverse
+                  ? {
+                      start: reversePositionInRange(range.end, seqLen, false),
+                      end: reversePositionInRange(range.start, seqLen, false)
+                    }
+                  : range),
+                strand: isReverse ? -1 : 1,
+                id: ann.id
+              });
+
+              reg.lastIndex = match.index + 1;
+            }
+          } catch (error) {
+            console.error(`error:`, error);
+          }
+        }
+        const seqLen = sequence.length;
+
+        const revSeq = getReverseComplementSequenceString(sequence);
+        getMatches({
+          seqLen,
+          seqToMatchAgainst: circular ? sequence + sequence : sequence
+        });
+        getMatches({
+          seqLen,
+          isReverse: true,
+          seqToMatchAgainst: circular ? revSeq + revSeq : revSeq
+        });
+      }
+    );
+  });
+
+  //loop through all patterns and get all matches
+
+  const toReturn: Record<string, Annotation[] | Record<string, string[]>> = {};
+
+  forEach(annotationsToAddBySeqId, (anns, id) => {
+    const origSeq = seqsToAnnotateById[id];
+    const alreadyExistingAnnsByStartEnd: Record<string, Annotation> = {};
+    forEach(origSeq.annotations, ann => {
+      alreadyExistingAnnsByStartEnd[
+        getStartEndStr(
+          { ...ann, strand: typeof ann.strand === "string" ? 1 : ann.strand },
+          { compareName }
+        )
+      ] = ann;
+    });
+    const warningCounter: Record<string, number> = {};
+    const toAdd = anns
+      .filter(ann => {
+        const alreadyExistingAnn =
+          alreadyExistingAnnsByStartEnd[
+            getStartEndStr(
+              {
+                ...ann,
+                strand: typeof ann.strand === "string" ? 1 : ann.strand
+              },
+              { compareName }
+            )
+          ];
+        if (alreadyExistingAnn) return false;
+        if (warnIfMoreThan && ann.id !== undefined) {
+          warningCounter[String(ann.id)] =
+            (warningCounter[String(ann.id)] || 0) + 1;
+        }
+        return true;
+      })
+      .sort((a, b) => a.start - b.start);
+    if (toAdd.length) {
+      toReturn[id] = toAdd;
+    }
+    warnIfMoreThan &&
+      forEach(warningCounter, (num, annId) => {
+        if (num > warnIfMoreThan) {
+          const warnings =
+            (toReturn["__more_than_warnings"] as Record<string, string[]>) ||
+            {};
+          warnings[id] = warnings[id] || [];
+          warnings[id].push(annId);
+          toReturn["__more_than_warnings"] = warnings;
+        }
+      });
+  });
+  return toReturn;
+}
+
+function getStartEndStr(
+  {
+    start,
+    end,
+    name,
+    strand,
+    forward
+  }: {
+    start: number;
+    end: number;
+    name?: string;
+    strand?: number;
+    forward?: boolean;
+  },
+  { compareName }: { compareName: boolean | undefined }
+) {
+  const isReverse = strand === -1 || forward === false;
+  return `${start}-${end}-${isReverse ? "rev" : "for"}-${
+    compareName ? name : ""
+  }`;
+}
+
+function convertApELikeRegexToRegex(regString = "") {
+  let newstr = "";
+  let rightOfCaretHolder = "";
+  let afterRightCaretHolder = "";
+  let beforeRightCaret = "";
+  let prevBp: string | undefined;
+  let hitLeftCaret: boolean | undefined;
+  let hitRightCaret: boolean | undefined;
+
+  // eslint-disable-next-line no-unused-vars
+  for (const bp of regString.replace("(", "").replace(")", "")) {
+    /* eslint-disable no-loop-func*/
+    /* eslint-disable no-inner-declarations*/
+    function maybeHandleRightCaret(justAdded: string) {
+      if (hitRightCaret) {
+        rightOfCaretHolder += justAdded;
+        afterRightCaretHolder = `${rightOfCaretHolder}${
+          afterRightCaretHolder.length ? "|" : ""
+        }${afterRightCaretHolder}`;
+      }
+    }
+    /* eslint-enable no-loop-func*/
+    /* eslint-enable no-inner-declarations*/
+    const ambigVal = ambiguous_dna_values[bp.toUpperCase()];
+    if (ambigVal && ambigVal.length > 1) {
+      let valToUse;
+      if (ambigVal.length === 4) {
+        valToUse = ".";
+      } else {
+        valToUse = `[${ambigVal}]`;
+      }
+      newstr += valToUse;
+      maybeHandleRightCaret(valToUse);
+      continue;
+    }
+    if (bp === "#") {
+      if (hitRightCaret) throw new Error("Error converting regex");
+      const valToUse = prevBp ? `[^${prevBp}]*?` : `.*?`;
+      newstr += valToUse;
+      maybeHandleRightCaret(valToUse);
+      continue;
+    }
+    if (bp === "<") {
+      if (hitRightCaret) throw new Error("Error converting to regex");
+      if (hitLeftCaret) throw new Error("Error converting to regex");
+      let holder = "";
+      let stringToAdd = "";
+      let isGroupClosed = true;
+      let closingBraceHit;
+      const groups = [];
+      for (let index = 0; index < newstr.length; index++) {
+        const char = newstr[index];
+        const nextChar = newstr[index + 1];
+        if (char === "[") {
+          isGroupClosed = false;
+        } else if (char === "]" || closingBraceHit) {
+          closingBraceHit = true;
+          if (ambiguous_dna_values[nextChar] || nextChar === "[") {
+            isGroupClosed = true;
+            closingBraceHit = false;
+          }
+        }
+        holder += char;
+        if (isGroupClosed) {
+          groups.push(holder);
+          holder = "";
+        }
+      }
+      let concattedEls = "";
+      groups.reverse();
+      groups.forEach(g => {
+        concattedEls = g + concattedEls;
+        stringToAdd = `${concattedEls}${
+          stringToAdd.length ? "|" : ""
+        }${stringToAdd}`;
+      });
+      newstr = `(${stringToAdd})?`;
+      hitLeftCaret = true;
+      continue;
+    }
+    if (bp === ">") {
+      if (hitRightCaret) throw new Error("Error converting regex");
+      hitRightCaret = true;
+      beforeRightCaret = newstr;
+      continue;
+    }
+    newstr += bp;
+    maybeHandleRightCaret(bp);
+    prevBp = bp;
+  }
+  if (hitRightCaret) {
+    newstr = `${beforeRightCaret}(${afterRightCaretHolder})?`;
+  }
+  return newstr;
+}
+function convertProteinSeqToDNAIupac(sequence: string) {
+  let toRet = "";
+  let l;
+  for (l of sequence) {
+    const degenDna = aminoAcidToDegenerateDnaMap[l.toLowerCase()];
+    if (degenDna) {
+      toRet += degenDna;
+    } else {
+      toRet += l;
+    }
+  }
+
+  return toRet;
+}
+
+export {
+  convertProteinSeqToDNAIupac,
+  convertApELikeRegexToRegex,
+  autoAnnotate
+};

package/src/bioData.ts

@@ -0,0 +1,65 @@
+//Adapted from biopython. Check the BIOPYTHON_LICENSE for licensing info
+
+export const protein_letters = "ACDEFGHIKLMNPQRSTVWY";
+export const protein_letters_withUandX = "ACDEFGHIKLMNPQRSTVWYUX";
+export const extended_protein_letters = "ACDEFGHIKLMNPQRSTVWYBXZJUO*";
+export const ambiguous_dna_letters = "GATCRYWSMKHBVDN";
+export const unambiguous_dna_letters = "GATC";
+export const ambiguous_rna_letters = "GAUCRYWSMKHBVDN";
+export const unambiguous_rna_letters = "GAUC";
+export const extended_dna_letters = "GATCBDSW";
+
+export const ambiguous_dna_values: Record<string, string> = {
+  ".": ".",
+  A: "A",
+  C: "C",
+  G: "G",
+  T: "T",
+  M: "AC",
+  R: "AG",
+  W: "AT",
+  S: "CG",
+  Y: "CT",
+  K: "GT",
+  V: "ACG",
+  H: "ACT",
+  D: "AGT",
+  B: "CGT",
+  X: "GATC",
+  N: "GATC"
+};
+
+export const extended_protein_values: Record<string, string> = {
+  A: "A",
+  B: "ND",
+  C: "C",
+  D: "D",
+  E: "E",
+  F: "F",
+  G: "G",
+  H: "H",
+  I: "I",
+  J: "IL",
+  K: "K",
+  L: "L",
+  M: "M",
+  N: "N",
+  O: "O",
+  P: "P",
+  Q: "Q",
+  R: "R",
+  S: "S",
+  T: "T",
+  U: "U",
+  V: "V",
+  W: "W",
+  X: "ACDEFGHIKLMNPQRSTVWY",
+  // # TODO - Include U and O in the possible values of X?
+  // # This could alter the extended_protein_weight_ranges ...
+  // # by MP: Won't do this, because they are so rare.
+  Y: "Y",
+  Z: "QE",
+  "*": "\\*\\.",
+  ".": "\\.",
+  "-": "\\-"
+};

package/src/calculateEndStability.ts

@@ -0,0 +1,91 @@
+import {
+  isValidSequence,
+  SANTA_LUCIA_NN,
+  SANTA_LUCIA_INIT,
+  SantaLuciaParams
+} from "./calculateSantaLuciaTm";
+
+/**
+ * Calculate End Stability (3' end stability) of a primer
+ *
+ * The maximum stability for the last five 3' bases of a left or right primer.
+ * Bigger numbers mean more stable 3' ends. The value is the maximum delta G
+ * (kcal/mol) for duplex disruption for the five 3' bases.
+ *
+ * According to Primer3 documentation:
+ * - Most stable 5mer duplex: GCGCG = 6.86 kcal/mol (SantaLucia 1998)
+ * - Most labile 5mer duplex: TATAT = 0.86 kcal/mol (SantaLucia 1998)
+ *
+ * @param {string} sequence - DNA sequence (5' to 3')
+ * @returns {number} - Delta G (kcal/mol) for the last 5 bases at 3' end
+ * @throws {Error} Invalid sequence or too short.
+ */
+export default function calculateEndStability(
+  sequence: string
+): number | string {
+  try {
+    const seq = sequence?.toUpperCase().trim();
+
+    if (!isValidSequence(seq)) {
+      throw new Error("Invalid sequence: contains non-DNA characters");
+    }
+
+    if (seq.length < 5) {
+      throw new Error(
+        "Sequence too short: minimum length is 5 bases for end stability calculation"
+      );
+    }
+
+    const last5Bases = seq.substring(seq.length - 5);
+
+    let deltaH = 0; // kcal/mol
+    let deltaS = 0; // cal/K·mol
+
+    // Calculate nearest-neighbor contributions for the 4 dinucleotides
+    for (let i = 0; i < 4; i++) {
+      const dinucleotide = last5Bases.substring(i, i + 2);
+
+      if (dinucleotide.includes("N")) {
+        continue;
+      }
+
+      const params = (SANTA_LUCIA_NN as Record<string, SantaLuciaParams>)[
+        dinucleotide
+      ];
+      if (params) {
+        deltaH += params.dH;
+        deltaS += params.dS;
+      }
+    }
+
+    // Add initiation parameters for terminal base pairs
+    const firstBase = last5Bases[0];
+    const lastBase = last5Bases[last5Bases.length - 1];
+
+    // Terminal GC or AT initiation
+    if (firstBase === "G" || firstBase === "C") {
+      deltaH += SANTA_LUCIA_INIT["GC"].dH;
+      deltaS += SANTA_LUCIA_INIT["GC"].dS;
+    } else {
+      deltaH += SANTA_LUCIA_INIT["AT"].dH;
+      deltaS += SANTA_LUCIA_INIT["AT"].dS;
+    }
+
+    if (lastBase === "G" || lastBase === "C") {
+      deltaH += SANTA_LUCIA_INIT["GC"].dH;
+      deltaS += SANTA_LUCIA_INIT["GC"].dS;
+    } else {
+      deltaH += SANTA_LUCIA_INIT["AT"].dH;
+      deltaS += SANTA_LUCIA_INIT["AT"].dS;
+    }
+
+    // Calculate deltaG at 37°C (310.15 K)
+    // deltaG = deltaH - T * deltaS
+    const T = 310.15; // 37°C in Kelvin
+    const deltaG = deltaH - (T * deltaS) / 1000; // Result in kcal/mol
+
+    return Math.round(Math.abs(deltaG) * 100) / 100;
+  } catch (e) {
+    return `Error calculating end stability for sequence ${sequence}. ${e}`;
+  }
+}

package/src/calculateNebTa.ts

@@ -0,0 +1,46 @@
+import calculateTm from "./calculateNebTm";
+
+interface NebTaOptions {
+  monovalentCationConc?: number;
+  polymerase?: string;
+}
+
+export default function calculateNebTa(
+  sequences: string[],
+  primerConc: number,
+  { monovalentCationConc, polymerase }: NebTaOptions = {}
+): number | string {
+  try {
+    if (sequences.length !== 2) {
+      throw new Error(
+        `${sequences.length} sequences received when 2 primers were expected`
+      );
+    }
+    // Type assertion or check return type of calculateTm if it can be number | string
+    // Assuming calculateTm returns number | string based on previous pattern
+    const meltingTemperatures = sequences.map(seq => {
+      const tm = calculateTm(seq, { monovalentCationConc, primerConc });
+      if (typeof tm !== "number") {
+        throw new Error(`Invalid Tm calculated for ${seq}: ${tm}`);
+      }
+      return tm;
+    });
+
+    meltingTemperatures.sort((a, b) => a - b);
+    const lowerMeltingTemp = meltingTemperatures[0];
+    let annealingTemp: number;
+    if (polymerase === "Q5") {
+      // Ta = Tm_lower+1°C is standard for Q5
+      annealingTemp = lowerMeltingTemp + 1;
+      if (annealingTemp > 72) {
+        // "Annealing temperature for experiments with this enzyme should typically not exceed 72°C"
+        annealingTemp = 72;
+      }
+    } else {
+      annealingTemp = lowerMeltingTemp - 3;
+    }
+    return annealingTemp;
+  } catch (err) {
+    return `Error calculating annealing temperature: ${err}`;
+  }
+}