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

package/src/diffUtils.ts

@@ -0,0 +1,80 @@
+import { cloneDeep, forEach } from "lodash-es";
+import { diff, patch, reverse, Delta } from "jsondiffpatch";
+import { SequenceData } from "./types";
+
+import tidyUpSequenceData from "./tidyUpSequenceData";
+
+interface DiffOptions {
+  ignoreKeys?: string[];
+}
+
+const getDiffFromSeqs = (
+  oldData: SequenceData,
+  newData: SequenceData,
+  { ignoreKeys = [] }: DiffOptions = {}
+): Delta | undefined => {
+  /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+  const cleanedOldData: any = tidyUpSequenceData(oldData, {
+    annotationsAsObjects: true,
+    noTranslationData: true,
+    doNotRemoveInvalidChars: true
+  });
+  /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+  const cleanedNewData: any = tidyUpSequenceData(newData, {
+    annotationsAsObjects: true,
+    noTranslationData: true,
+    doNotRemoveInvalidChars: true
+  });
+
+  [cleanedOldData, cleanedNewData].forEach(d => {
+    [
+      "cutsites",
+      "orfs",
+      "filteredFeatures",
+      "size",
+      "fromFileUpload",
+      "description",
+      "materiallyAvailable",
+      ...ignoreKeys
+    ].forEach(prop => {
+      delete d[prop];
+    });
+    if (d.translations) {
+      forEach(d.translations, (translation, key) => {
+        if (
+          translation.translationType &&
+          translation.translationType !== "User Created"
+        ) {
+          delete d.translations[key];
+        } else {
+          delete translation.aminoAcids;
+        }
+      });
+    }
+  });
+
+  return diff(cleanedOldData, cleanedNewData);
+};
+
+const patchSeqWithDiff = (
+  oldData: SequenceData,
+  diffData: Delta,
+  { ignoreKeys = [] }: DiffOptions = {}
+): SequenceData => {
+  ignoreKeys.forEach(k => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    delete (diffData as any)[k];
+  });
+  const tidyOld = tidyUpSequenceData(cloneDeep(oldData), {
+    annotationsAsObjects: true,
+    doNotRemoveInvalidChars: true
+  });
+
+  return patch(tidyOld, diffData) as SequenceData;
+};
+
+const reverseSeqDiff = (diffData: Delta): Delta | undefined => {
+  return reverse(diffData);
+};
+
+export { getDiffFromSeqs, patchSeqWithDiff, reverseSeqDiff };

package/src/doesEnzymeChopOutsideOfRecognitionSite.ts

@@ -0,0 +1,16 @@
+import { RestrictionEnzyme } from "./types";
+
+export default function doesEnzymeChopOutsideOfRecognitionSite(
+  enzyme: RestrictionEnzyme
+): boolean {
+  if (
+    enzyme.topSnipOffset &&
+    enzyme.bottomSnipOffset &&
+    (enzyme.topSnipOffset > enzyme.site.length ||
+      enzyme.bottomSnipOffset > enzyme.site.length)
+  ) {
+    return true;
+  } else {
+    return false;
+  }
+}

package/src/featureTypesAndColors.js

@@ -17,7 +17,7 @@ const genbankFeatureTypes = [
   { name: "regulatory", color: "#3F6C51" },
   { name: "SecStr", color: "#7B4B94" },
   { name: "Site", color: "#7D82B8" },
-  { name: "telomere", color: "DE9151" },
+  { name: "telomere", color: "#DE9151" },
   { name: "tmRNA", color: "#B7E3CC" },
   { name: "unsure", color: "#C4FFB2" },
   { name: "V_segment", color: "#D6F7A3" },

package/src/featureTypesAndColors.ts

@@ -0,0 +1,167 @@
+import { get, keyBy, filter } from "lodash-es";
+
+interface FeatureType {
+  name: string;
+  color: string;
+  isHidden?: boolean;
+  isGenbankStandardType?: boolean;
+  isOverridden?: boolean;
+  isCustomType?: boolean;
+}
+
+const genbankFeatureTypes: FeatureType[] = [
+  { name: "-10_signal", color: "#4ECDC4" },
+  { name: "-35_signal", color: "#F7FFF7" },
+  { name: "3'clip", color: "#FF6B6B" },
+  { name: "3'UTR", color: "#FFE66D" },
+  { name: "5'clip", color: "#3E517A" },
+  { name: "5'UTR", color: "#BBBBBB" },
+  { name: "D-loop", color: "#F13C73" },
+  { name: "assembly_gap", color: "#DE9151" },
+  { name: "centromere", color: "#F34213" },
+  { name: "Het", color: "#BC5D2E" },
+  { name: "mobile_element", color: "#6DB1BF" },
+  { name: "ncRNA", color: "#FFEAEC" },
+  { name: "proprotein", color: "#F39A9D" },
+  { name: "regulatory", color: "#3F6C51" },
+  { name: "SecStr", color: "#7B4B94" },
+  { name: "Site", color: "#7D82B8" },
+  { name: "telomere", color: "#DE9151" },
+  { name: "tmRNA", color: "#B7E3CC" },
+  { name: "unsure", color: "#C4FFB2" },
+  { name: "V_segment", color: "#D6F7A3" },
+  { name: "allele", color: "#D86D6D" },
+  { name: "attenuator", color: "#6B7F9C" },
+  { name: "C_region", color: "#B5D89D" },
+  { name: "CAAT_signal", color: "#E9CD98" },
+  { name: "CDS", color: "#EF6500" },
+  { name: "conserved", color: "#A3A5F0" },
+  { name: "D_segment", color: "#C060F7" },
+  { name: "default", color: "#CCCCCC" },
+  { name: "enhancer", color: "#38F872" },
+  { name: "exon", color: "#95F844" },
+  { name: "gap", color: "#F7D43C" },
+  { name: "GC_signal", color: "#861F1F" },
+  { name: "gene", color: "#684E27" },
+  { name: "iDNA", color: "#A59B41" },
+  { name: "intron", color: "#52963E" },
+  { name: "J_region", color: "#369283" },
+  { name: "LTR", color: "#31748F" },
+  { name: "m_rna", color: "#FFFF00" },
+  { name: "mat_peptide", color: "#353E8F" },
+  { name: "misc_binding", color: "#006FEF" },
+  { name: "misc_difference", color: "#5A368A" },
+  { name: "misc_feature", color: "#006FEF" },
+  { name: "misc_marker", color: "#8DCEB1" },
+  { name: "misc_part", color: "#006FEF" },
+  { name: "misc_recomb", color: "#DD97B4" },
+  { name: "misc_RNA", color: "#BD0101" },
+  { name: "misc_signal", color: "#FF9A04" },
+  { name: "misc_structure", color: "#B3FF00" },
+  { name: "modified_base", color: "#00F7FF" },
+  { name: "mRNA", color: "#FFD900" },
+  { name: "N_region", color: "#AE00FF" },
+  { name: "old_sequence", color: "#F0A7FF" },
+  { name: "operator", color: "#63004D" },
+  { name: "operon", color: "#000653" },
+  { name: "oriT", color: "#580000" },
+  { name: "plasmid", color: "#00635E" },
+  { name: "polyA_signal", color: "#BBBBBB" },
+  { name: "polyA_site", color: "#003328" },
+  { name: "precursor_RNA", color: "#443200" },
+  { name: "prim_transcript", color: "#665E4C" },
+  { name: "primer_bind", color: "#53d969" },
+  { name: "promoter", color: "#31B440" },
+  { name: "protein_bind", color: "#2E2E2E" },
+  { name: "protein_domain", color: "#4D4B4B" },
+  { name: "protein", color: "#696969" },
+  { name: "RBS", color: "#BDFFCB" },
+  { name: "rep_origin", color: "#878787" },
+  { name: "repeat_region", color: "#966363" },
+  { name: "repeat_unit", color: "#A16D8D" },
+  { name: "rRNA", color: "#9BF0FF" },
+  { name: "s_mutation", color: "#70A2FF" },
+  { name: "S_region", color: "#FF74A9" },
+  { name: "satellite", color: "#164E64" },
+  { name: "scRNA", color: "#A057FF" },
+  { name: "sig_peptide", color: "#2FFF8D" },
+  { name: "snoRNA", color: "#296B14" },
+  { name: "snRNA", color: "#A16249" },
+  { name: "source", color: "#0B17BD" },
+  { name: "start", color: "#D6A336" },
+  { name: "stem_loop", color: "#67069E" },
+  { name: "stop", color: "#D44FC9" },
+  { name: "STS", color: "#597FE7" },
+  { name: "tag", color: "#E419DA" },
+  { name: "TATA_signal", color: "#EB2B2B" },
+  { name: "terminator", color: "#F51600" },
+  { name: "transit_peptide", color: "#24D491" },
+  { name: "transposon", color: "#B6E436" },
+  { name: "tRNA", color: "#D1456F" },
+  { name: "V_region", color: "#7B5EE7" },
+  { name: "variation", color: "#2EE455" }
+];
+
+const getMergedFeatureMap = (): Record<string, FeatureType> => {
+  const keyedGBFeats = keyBy(
+    genbankFeatureTypes.map(f => ({
+      ...f,
+      isGenbankStandardType: true
+    })),
+    "name"
+  );
+  const featureOverrides: FeatureType[] =
+    ((typeof window !== "undefined" &&
+      get(window, "tg_featureTypeOverrides")) as unknown as FeatureType[]) ||
+    ((typeof global !== "undefined" &&
+      get(global, "tg_featureTypeOverrides")) as unknown as FeatureType[]) ||
+    [];
+
+  const mappedOverrides = featureOverrides.map(fo => {
+    const originalGenbankFeat = keyedGBFeats[fo.name];
+    return {
+      ...originalGenbankFeat,
+      ...fo,
+      ...(originalGenbankFeat ? { isOverridden: true } : { isCustomType: true })
+    };
+  });
+  const keyedOverrides = keyBy(mappedOverrides, "name");
+
+  return {
+    ...keyedGBFeats,
+    ...keyedOverrides
+  };
+};
+
+const getFeatureToColorMap = ({
+  includeHidden
+}: { includeHidden?: boolean } = {}): Record<string, string> => {
+  const toRet: Record<string, string> = {};
+  filter(getMergedFeatureMap(), f =>
+    includeHidden ? true : !f.isHidden
+  ).forEach(f => {
+    toRet[f.name] = f.color;
+  });
+  return toRet;
+};
+
+const getFeatureTypes = ({
+  includeHidden
+}: { includeHidden?: boolean } = {}): string[] =>
+  filter(getMergedFeatureMap(), f => (includeHidden ? true : !f.isHidden)).map(
+    f => f.name
+  );
+
+export { genbankFeatureTypes };
+
+export function getGenbankFeatureToColorMap(): Record<string, string> {
+  const toRet: Record<string, string> = {};
+  genbankFeatureTypes.forEach(({ name, color }) => {
+    toRet[name] = color;
+  });
+  return toRet;
+}
+
+export { getFeatureToColorMap };
+export { getFeatureTypes };
+export { getMergedFeatureMap };

package/src/filterSequenceString.ts

@@ -0,0 +1,153 @@
+import { debounce, uniq } from "lodash-es";
+import {
+  ambiguous_dna_letters,
+  ambiguous_rna_letters,
+  extended_protein_letters
+} from "./bioData";
+
+let allWarnings: string[] = [];
+
+let makeToast = () => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  if (typeof window !== "undefined" && (window as any).toastr && allWarnings.length) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (window as any).toastr.warning(uniq(allWarnings).join("\n"));
+  }
+  allWarnings = [];
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+(makeToast as any) = debounce(makeToast, 200);
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function showWarnings(warnings: any) {
+  allWarnings = allWarnings.concat(warnings);
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  (makeToast as any).cancel();
+  makeToast();
+}
+
+interface FilterSequenceStringOptions {
+  additionalValidChars?: string;
+  isOligo?: boolean;
+  name?: string;
+  isProtein?: boolean;
+  isRna?: boolean;
+  isMixedRnaAndDna?: boolean;
+  [key: string]: unknown;
+}
+
+export default function filterSequenceString(
+  sequenceString = "",
+  {
+    additionalValidChars = "",
+    isOligo,
+    name,
+    isProtein,
+    isRna,
+    isMixedRnaAndDna
+  }: FilterSequenceStringOptions = {}
+): [string, string[]] {
+  const acceptedChars = getAcceptedChars({
+    isOligo,
+    isProtein,
+    isRna,
+    isMixedRnaAndDna
+  });
+  const replaceChars = getReplaceChars({
+    isOligo,
+    isProtein,
+    isRna,
+    isMixedRnaAndDna
+  });
+
+  let sanitizedVal = "";
+  const invalidChars: string[] = [];
+  const chars = `${acceptedChars}${additionalValidChars.split("").join("\\")}`;
+  const warnings: string[] = [];
+  const replaceCount: Record<string, number> = {};
+  sequenceString.split("").forEach(letter => {
+    const lowerLetter = letter.toLowerCase();
+    if (replaceChars && replaceChars[lowerLetter]) {
+      if (!replaceCount[lowerLetter]) {
+        replaceCount[lowerLetter] = 0;
+      }
+      replaceCount[lowerLetter]++;
+      const isUpper = lowerLetter !== letter;
+      sanitizedVal += isUpper
+        ? replaceChars[lowerLetter].toUpperCase()
+        : replaceChars[lowerLetter];
+    } else if (chars.includes(lowerLetter)) {
+      sanitizedVal += letter;
+    } else {
+      invalidChars.push(letter);
+    }
+  });
+  //add replace count warnings
+  Object.keys(replaceCount).forEach(letter => {
+    warnings.push(
+      `Replaced "${letter}" with "${replaceChars[letter]}"${replaceCount[letter] > 1 ? ` ${replaceCount[letter]} times` : ""
+      }`
+    );
+  });
+  if (sequenceString.length !== sanitizedVal.length) {
+    warnings.push(
+      `${name ? `Sequence ${name}: ` : ""
+      }Invalid character(s) detected and removed: ${uniq(invalidChars)
+        .map(c => {
+          if (c === " ") {
+            return "space";
+          }
+          return c;
+        })
+        .slice(0, 100)
+        .join(", ")} `
+    );
+  }
+  showWarnings(warnings);
+
+  return [sanitizedVal, warnings];
+}
+
+export function getAcceptedChars({
+  isOligo,
+  isProtein,
+  isRna,
+  isMixedRnaAndDna
+}: FilterSequenceStringOptions = {}) {
+  return isProtein
+    ? `${extended_protein_letters.toLowerCase()}`
+    : isOligo
+      ? ambiguous_rna_letters.toLowerCase() + "t"
+      : isRna
+        ? ambiguous_rna_letters.toLowerCase() + "t"
+        : isMixedRnaAndDna
+          ? ambiguous_rna_letters.toLowerCase() +
+          ambiguous_dna_letters.toLowerCase()
+          : //just plain old dna
+          ambiguous_rna_letters.toLowerCase() +
+          ambiguous_dna_letters.toLowerCase();
+}
+export function getReplaceChars({
+  isOligo,
+  isProtein,
+  isRna,
+  isMixedRnaAndDna
+}: FilterSequenceStringOptions = {}): Record<string, string> {
+  return isProtein
+    ? {}
+    : // {".": "*"}
+    isOligo
+      ? {}
+      : isRna
+        ? { t: "u" }
+        : isMixedRnaAndDna
+          ? {}
+          : //just plain old dna
+          {};
+}
+
+export const filterRnaString = (
+  s: string,
+  o: FilterSequenceStringOptions
+): string => filterSequenceString(s, { ...o, isRna: true })[0];

package/src/findApproxMatches.ts

@@ -0,0 +1,58 @@
+/**
+ * Find approximate matches of a search sequence within a target sequence
+ *
+ * @param {string} searchSeq - The sequence to search for
+ * @param {string} targetSeq - The sequence to search within
+ * @param {number} maxMismatches - Maximum number of mismatches allowed
+ * @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: string,
+  targetSeq: string,
+  maxMismatches: number,
+  circular = false
+): ApproxMatch[] {
+  const matches: ApproxMatch[] = [];
+  const lenA = searchSeq.length;
+  const lenB = targetSeq.length;
+
+  // Extend targetSeq to simulate circularity, in case circular = true
+  const targetSeqExtended = circular
+    ? targetSeq + targetSeq.slice(0, lenA - 1)
+    : targetSeq;
+  const limit = circular ? lenB : lenB - lenA + 1;
+
+  for (let i = 0; i < limit; i++) {
+    const window = targetSeqExtended.slice(i, i + lenA);
+    let mismatchCount = 0;
+    const mismatchPositions: number[] = [];
+
+    for (let j = 0; j < lenA; j++) {
+      if (searchSeq[j] !== window[j]) {
+        mismatchPositions.push(j);
+        mismatchCount++;
+        if (mismatchCount > maxMismatches) break;
+      }
+    }
+
+    if (mismatchCount <= maxMismatches) {
+      matches.push({
+        index: i,
+        match: window,
+        mismatchPositions,
+        numMismatches: mismatchPositions.length // Keep for backwards compatibility
+      });
+    }
+  }
+
+  return matches;
+}

package/src/findNearestRangeOfSequenceOverlapToPosition.ts

@@ -0,0 +1,43 @@
+import { normalizeRange, Range } from "@teselagen/range-utils";
+function findNearestRangeOfSequenceOverlapToPosition(
+  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: RegExpExecArray | null;
+  let index: number | undefined;
+  let distance = Infinity;
+  while (
+    (result = regex.exec(sequenceToSearch + (isLinear ? "" : sequenceToSearch)))
+  ) {
+    if (result.index > sequenceToSearch.length) break;
+    let newDistance = Math.abs(result.index - positionStart);
+    newDistance = isLinear
+      ? newDistance //if linear, don't check around the origin
+      : Math.min(newDistance, Math.abs(newDistance - sequenceToSearch.length));
+    if (newDistance > distance) {
+      break;
+    }
+    index = result.index;
+    distance = newDistance;
+  }
+
+  if (index === undefined) {
+    return null;
+  }
+
+  //index is the closest range start
+  return normalizeRange(
+    {
+      start: index,
+      end: index + overlapSequence.length - 1
+    },
+    sequenceToSearch.length
+  );
+}
+export default findNearestRangeOfSequenceOverlapToPosition;

package/src/findOrfsInPlasmid.js

@@ -4,8 +4,13 @@ export default function findOrfsInPlasmid(
   sequence,
   circular,
   minimumOrfSize,
-  useAdditionalOrfStartCodons
+  useAdditionalOrfStartCodons,
+  isProteinOrOligo
 ) {
+  if (isProteinOrOligo) {
+    // we do not find ORFs in protein/oligo sequences
+    return [];
+  }
   //tnr, we should do the parsing down of the orfs immediately after they're returned from this sequence
   // const orfs1Forward = eliminateCircularOrfsThatOverlapWithNonCircularOrfs(getOrfsFromSequence(0, doubleForwardSequence, minimumOrfSize, true), maxLength);
   const forwardOrfs = getOrfsFromSequence({

package/src/findOrfsInPlasmid.ts

@@ -0,0 +1,31 @@
+import getOrfsFromSequence, { Orf } from "./getOrfsFromSequence";
+
+export default function findOrfsInPlasmid(
+  sequence: string,
+  circular: boolean,
+  minimumOrfSize: number,
+  useAdditionalOrfStartCodons: boolean,
+  isProteinOrOligo: boolean
+): Orf[] {
+  if (isProteinOrOligo) {
+    // we do not find ORFs in protein/oligo sequences
+    return [];
+  }
+  //tnr, we should do the parsing down of the orfs immediately after they're returned from this sequence
+  // const orfs1Forward = eliminateCircularOrfsThatOverlapWithNonCircularOrfs(getOrfsFromSequence(0, doubleForwardSequence, minimumOrfSize, true), maxLength);
+  const forwardOrfs = getOrfsFromSequence({
+    sequence: sequence,
+    minimumOrfSize: minimumOrfSize,
+    forward: true,
+    circular: circular,
+    useAdditionalOrfStartCodons
+  });
+  const reverseOrfs = getOrfsFromSequence({
+    sequence: sequence,
+    minimumOrfSize: minimumOrfSize,
+    forward: false,
+    circular: circular,
+    useAdditionalOrfStartCodons
+  });
+  return forwardOrfs.concat(reverseOrfs);
+}