@teselagen/sequence-utils 0.3.31 → 0.3.32-beta.1

package/findApproxMatches.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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 default function findApproxMatches(searchSeq: string, targetSeq: string, maxMismatches: number, circular?: boolean): any[];

package/findApproxMatches.test.d.ts

@@ -0,0 +1 @@
+export {};

package/index.cjs

@@ -2736,30 +2736,31 @@ function adjustRangeToDeletionOfAnotherRange(rangeToBeAdjusted, anotherRange, ma
     anotherRange,
     maxLength
   );
-  if (trimmedRange) {
-    const nonCircularDeletionRanges = splitRangeIntoTwoPartsIfItIsCircular(
-      anotherRange,
-      maxLength
-    );
-    nonCircularDeletionRanges.forEach(function(nonCircularDeletionRange) {
-      const deletionLength = nonCircularDeletionRange.end - nonCircularDeletionRange.start + 1;
-      if (trimmedRange.start > trimmedRange.end) {
-        if (nonCircularDeletionRange.start < trimmedRange.end) {
-          trimmedRange.start -= deletionLength;
-          trimmedRange.end -= deletionLength;
-        } else if (nonCircularDeletionRange.start < trimmedRange.start) {
-          trimmedRange.start -= deletionLength;
-        } else ;
-      } else {
-        if (nonCircularDeletionRange.start < trimmedRange.start) {
-          trimmedRange.start -= deletionLength;
-          trimmedRange.end -= deletionLength;
-        } else if (nonCircularDeletionRange.start < trimmedRange.end) {
-          trimmedRange.end -= deletionLength;
-        } else ;
-      }
-    });
+  if (!trimmedRange) {
+    return null;
   }
+  const nonCircularDeletionRanges = splitRangeIntoTwoPartsIfItIsCircular(
+    anotherRange,
+    maxLength
+  );
+  nonCircularDeletionRanges.forEach(function(nonCircularDeletionRange) {
+    const deletionLength = nonCircularDeletionRange.end - nonCircularDeletionRange.start + 1;
+    if (trimmedRange.start > trimmedRange.end) {
+      if (nonCircularDeletionRange.start < trimmedRange.end) {
+        trimmedRange.start -= deletionLength;
+        trimmedRange.end -= deletionLength;
+      } else if (nonCircularDeletionRange.start < trimmedRange.start) {
+        trimmedRange.start -= deletionLength;
+      } else ;
+    } else {
+      if (nonCircularDeletionRange.start < trimmedRange.start) {
+        trimmedRange.start -= deletionLength;
+        trimmedRange.end -= deletionLength;
+      } else if (nonCircularDeletionRange.start < trimmedRange.end) {
+        trimmedRange.end -= deletionLength;
+      } else ;
+    }
+  });
   return trimmedRange;
 }
 __name(adjustRangeToDeletionOfAnotherRange, "adjustRangeToDeletionOfAnotherRange");
@@ -9514,6 +9515,36 @@ function insertGapsIntoRefSeq(refSeq, seqReads) {
   return refSeqWithGaps.join("");
 }
 __name(insertGapsIntoRefSeq, "insertGapsIntoRefSeq");
+function findApproxMatches(searchSeq, targetSeq, maxMismatches, circular = false) {
+  const matches = [];
+  const lenA = searchSeq.length;
+  const lenB = targetSeq.length;
+  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 window2 = targetSeqExtended.slice(i, i + lenA);
+    let mismatchCount = 0;
+    const mismatchPositions = [];
+    for (let j = 0; j < lenA; j++) {
+      if (searchSeq[j] !== window2[j]) {
+        mismatchPositions.push(j);
+        mismatchCount++;
+        if (mismatchCount > maxMismatches) break;
+      }
+    }
+    if (mismatchCount <= maxMismatches) {
+      matches.push({
+        index: i,
+        match: window2,
+        mismatchPositions,
+        numMismatches: mismatchPositions.length
+        // Keep for backwards compatibility
+      });
+    }
+  }
+  return matches;
+}
+__name(findApproxMatches, "findApproxMatches");
 var spliceString$1;
 var hasRequiredSpliceString;
 function requireSpliceString() {
@@ -19322,6 +19353,7 @@ exports.doesEnzymeChopOutsideOfRecognitionSite = doesEnzymeChopOutsideOfRecognit
 exports.featureColors = featureColors;
 exports.filterRnaString = filterRnaString;
 exports.filterSequenceString = filterSequenceString;
+exports.findApproxMatches = findApproxMatches;
 exports.findNearestRangeOfSequenceOverlapToPosition = findNearestRangeOfSequenceOverlapToPosition;
 exports.findOrfsInPlasmid = findOrfsInPlasmid;
 exports.findSequenceMatches = findSequenceMatches;

package/index.d.ts

@@ -11,6 +11,7 @@ export { default as getDegenerateRnaStringFromAAString } from './getDegenerateRn
 export { default as getVirtualDigest } from './getVirtualDigest';
 export { default as isEnzymeType2S } from './isEnzymeType2S';
 export { default as insertGapsIntoRefSeq } from './insertGapsIntoRefSeq';
+export { default as findApproxMatches } from './findApproxMatches';
 export { default as adjustBpsToReplaceOrInsert } from './adjustBpsToReplaceOrInsert';
 export { default as calculatePercentGC } from './calculatePercentGC';
 export { default as calculateTm } from './calculateTm';

package/index.js

@@ -2734,30 +2734,31 @@ function adjustRangeToDeletionOfAnotherRange(rangeToBeAdjusted, anotherRange, ma
     anotherRange,
     maxLength
   );
-  if (trimmedRange) {
-    const nonCircularDeletionRanges = splitRangeIntoTwoPartsIfItIsCircular(
-      anotherRange,
-      maxLength
-    );
-    nonCircularDeletionRanges.forEach(function(nonCircularDeletionRange) {
-      const deletionLength = nonCircularDeletionRange.end - nonCircularDeletionRange.start + 1;
-      if (trimmedRange.start > trimmedRange.end) {
-        if (nonCircularDeletionRange.start < trimmedRange.end) {
-          trimmedRange.start -= deletionLength;
-          trimmedRange.end -= deletionLength;
-        } else if (nonCircularDeletionRange.start < trimmedRange.start) {
-          trimmedRange.start -= deletionLength;
-        } else ;
-      } else {
-        if (nonCircularDeletionRange.start < trimmedRange.start) {
-          trimmedRange.start -= deletionLength;
-          trimmedRange.end -= deletionLength;
-        } else if (nonCircularDeletionRange.start < trimmedRange.end) {
-          trimmedRange.end -= deletionLength;
-        } else ;
-      }
-    });
+  if (!trimmedRange) {
+    return null;
   }
+  const nonCircularDeletionRanges = splitRangeIntoTwoPartsIfItIsCircular(
+    anotherRange,
+    maxLength
+  );
+  nonCircularDeletionRanges.forEach(function(nonCircularDeletionRange) {
+    const deletionLength = nonCircularDeletionRange.end - nonCircularDeletionRange.start + 1;
+    if (trimmedRange.start > trimmedRange.end) {
+      if (nonCircularDeletionRange.start < trimmedRange.end) {
+        trimmedRange.start -= deletionLength;
+        trimmedRange.end -= deletionLength;
+      } else if (nonCircularDeletionRange.start < trimmedRange.start) {
+        trimmedRange.start -= deletionLength;
+      } else ;
+    } else {
+      if (nonCircularDeletionRange.start < trimmedRange.start) {
+        trimmedRange.start -= deletionLength;
+        trimmedRange.end -= deletionLength;
+      } else if (nonCircularDeletionRange.start < trimmedRange.end) {
+        trimmedRange.end -= deletionLength;
+      } else ;
+    }
+  });
   return trimmedRange;
 }
 __name(adjustRangeToDeletionOfAnotherRange, "adjustRangeToDeletionOfAnotherRange");
@@ -9512,6 +9513,36 @@ function insertGapsIntoRefSeq(refSeq, seqReads) {
   return refSeqWithGaps.join("");
 }
 __name(insertGapsIntoRefSeq, "insertGapsIntoRefSeq");
+function findApproxMatches(searchSeq, targetSeq, maxMismatches, circular = false) {
+  const matches = [];
+  const lenA = searchSeq.length;
+  const lenB = targetSeq.length;
+  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 window2 = targetSeqExtended.slice(i, i + lenA);
+    let mismatchCount = 0;
+    const mismatchPositions = [];
+    for (let j = 0; j < lenA; j++) {
+      if (searchSeq[j] !== window2[j]) {
+        mismatchPositions.push(j);
+        mismatchCount++;
+        if (mismatchCount > maxMismatches) break;
+      }
+    }
+    if (mismatchCount <= maxMismatches) {
+      matches.push({
+        index: i,
+        match: window2,
+        mismatchPositions,
+        numMismatches: mismatchPositions.length
+        // Keep for backwards compatibility
+      });
+    }
+  }
+  return matches;
+}
+__name(findApproxMatches, "findApproxMatches");
 var spliceString$1;
 var hasRequiredSpliceString;
 function requireSpliceString() {
@@ -19321,6 +19352,7 @@ export {
   featureColors,
   filterRnaString,
   filterSequenceString,
+  findApproxMatches,
   findNearestRangeOfSequenceOverlapToPosition,
   findOrfsInPlasmid,
   findSequenceMatches,

package/index.umd.cjs

@@ -2738,30 +2738,31 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
       anotherRange,
       maxLength
     );
-    if (trimmedRange) {
-      const nonCircularDeletionRanges = splitRangeIntoTwoPartsIfItIsCircular(
-        anotherRange,
-        maxLength
-      );
-      nonCircularDeletionRanges.forEach(function(nonCircularDeletionRange) {
-        const deletionLength = nonCircularDeletionRange.end - nonCircularDeletionRange.start + 1;
-        if (trimmedRange.start > trimmedRange.end) {
-          if (nonCircularDeletionRange.start < trimmedRange.end) {
-            trimmedRange.start -= deletionLength;
-            trimmedRange.end -= deletionLength;
-          } else if (nonCircularDeletionRange.start < trimmedRange.start) {
-            trimmedRange.start -= deletionLength;
-          } else ;
-        } else {
-          if (nonCircularDeletionRange.start < trimmedRange.start) {
-            trimmedRange.start -= deletionLength;
-            trimmedRange.end -= deletionLength;
-          } else if (nonCircularDeletionRange.start < trimmedRange.end) {
-            trimmedRange.end -= deletionLength;
-          } else ;
-        }
-      });
+    if (!trimmedRange) {
+      return null;
     }
+    const nonCircularDeletionRanges = splitRangeIntoTwoPartsIfItIsCircular(
+      anotherRange,
+      maxLength
+    );
+    nonCircularDeletionRanges.forEach(function(nonCircularDeletionRange) {
+      const deletionLength = nonCircularDeletionRange.end - nonCircularDeletionRange.start + 1;
+      if (trimmedRange.start > trimmedRange.end) {
+        if (nonCircularDeletionRange.start < trimmedRange.end) {
+          trimmedRange.start -= deletionLength;
+          trimmedRange.end -= deletionLength;
+        } else if (nonCircularDeletionRange.start < trimmedRange.start) {
+          trimmedRange.start -= deletionLength;
+        } else ;
+      } else {
+        if (nonCircularDeletionRange.start < trimmedRange.start) {
+          trimmedRange.start -= deletionLength;
+          trimmedRange.end -= deletionLength;
+        } else if (nonCircularDeletionRange.start < trimmedRange.end) {
+          trimmedRange.end -= deletionLength;
+        } else ;
+      }
+    });
     return trimmedRange;
   }
   __name(adjustRangeToDeletionOfAnotherRange, "adjustRangeToDeletionOfAnotherRange");
@@ -9516,6 +9517,36 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     return refSeqWithGaps.join("");
   }
   __name(insertGapsIntoRefSeq, "insertGapsIntoRefSeq");
+  function findApproxMatches(searchSeq, targetSeq, maxMismatches, circular = false) {
+    const matches = [];
+    const lenA = searchSeq.length;
+    const lenB = targetSeq.length;
+    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 window2 = targetSeqExtended.slice(i, i + lenA);
+      let mismatchCount = 0;
+      const mismatchPositions = [];
+      for (let j = 0; j < lenA; j++) {
+        if (searchSeq[j] !== window2[j]) {
+          mismatchPositions.push(j);
+          mismatchCount++;
+          if (mismatchCount > maxMismatches) break;
+        }
+      }
+      if (mismatchCount <= maxMismatches) {
+        matches.push({
+          index: i,
+          match: window2,
+          mismatchPositions,
+          numMismatches: mismatchPositions.length
+          // Keep for backwards compatibility
+        });
+      }
+    }
+    return matches;
+  }
+  __name(findApproxMatches, "findApproxMatches");
   var spliceString$1;
   var hasRequiredSpliceString;
   function requireSpliceString() {
@@ -19324,6 +19355,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   exports2.featureColors = featureColors;
   exports2.filterRnaString = filterRnaString;
   exports2.filterSequenceString = filterSequenceString;
+  exports2.findApproxMatches = findApproxMatches;
   exports2.findNearestRangeOfSequenceOverlapToPosition = findNearestRangeOfSequenceOverlapToPosition;
   exports2.findOrfsInPlasmid = findOrfsInPlasmid;
   exports2.findSequenceMatches = findSequenceMatches;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teselagen/sequence-utils",
-  "version": "0.3.31",
+  "version": "0.3.32-beta.1",
   "type": "module",
   "dependencies": {
     "escape-string-regexp": "5.0.0",

package/src/findApproxMatches.js

@@ -0,0 +1,50 @@
+/**
+ * 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 default function findApproxMatches(
+  searchSeq,
+  targetSeq,
+  maxMismatches,
+  circular = false
+) {
+  const matches = [];
+  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 = [];
+
+    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/findApproxMatches.test.js

@@ -0,0 +1,126 @@
+import findApproxMatches from "./findApproxMatches";
+
+describe("findApproxMatches", () => {
+  it("returns exact matches with maxMismatches=0", () => {
+    // Test with DNA sequence
+    expect(findApproxMatches("ATG", "GATGC", 0)).toEqual([
+      { index: 1, match: "ATG", mismatchPositions: [], numMismatches: 0 }
+    ]);
+
+    // Test with no matches
+    expect(findApproxMatches("ATG", "GCCTA", 0)).toEqual([]);
+  });
+
+  it("finds matches with allowed mismatches", () => {
+    // One mismatch allowed, one actual mismatch
+    expect(findApproxMatches("ATG", "ACTG", 1)).toEqual([
+      { index: 1, match: "CTG", mismatchPositions: [0], numMismatches: 1 }
+    ]);
+
+    // Two mismatches allowed, two actual mismatches
+    expect(findApproxMatches("ATGC", "ACGA", 2)).toEqual([
+      { index: 0, match: "ACGA", mismatchPositions: [1, 3], numMismatches: 2 }
+    ]);
+
+    // Multiple matches with mismatches
+    expect(findApproxMatches("AGT", "AGTCAATAGTAAGTG", 1)).toEqual([
+      { index: 0, match: "AGT", mismatchPositions: [], numMismatches: 0 },
+      { index: 4, match: "AAT", mismatchPositions: [1], numMismatches: 1 },
+      { index: 7, match: "AGT", mismatchPositions: [], numMismatches: 0 },
+      { index: 11, match: "AGT", mismatchPositions: [], numMismatches: 0 }
+    ]);
+  });
+
+  it("respects the maximum mismatch threshold", () => {
+    // Three mismatches are too many when max is 2
+    expect(findApproxMatches("ATGC", "ACAA", 2)).toEqual([]);
+
+    // Three mismatches are allowed when max is 3
+    expect(findApproxMatches("ATGC", "ACAA", 3)).toEqual([
+      {
+        index: 0,
+        match: "ACAA",
+        mismatchPositions: [1, 2, 3],
+        numMismatches: 3
+      }
+    ]);
+  });
+
+  it("handles circular sequences correctly", () => {
+    // Non-circular sequence
+    expect(findApproxMatches("ATG", "TGA", 0, false)).toEqual([]);
+
+    // Circular sequence - match wraps around the end
+    expect(findApproxMatches("ATG", "TGA", 0, true)).toEqual([
+      { index: 2, match: "ATG", mismatchPositions: [], numMismatches: 0 }
+    ]);
+
+    // Circular sequence with mismatches
+    expect(findApproxMatches("ATG", "TGC", 1, true)).toEqual([
+      { index: 2, match: "CTG", mismatchPositions: [0], numMismatches: 1 }
+    ]);
+  });
+
+  it("handles edge cases", () => {
+    // Empty search sequence - returns matches at every position
+    expect(findApproxMatches("", "ATGC", 0)).toEqual([
+      { index: 0, match: "", mismatchPositions: [], numMismatches: 0 },
+      { index: 1, match: "", mismatchPositions: [], numMismatches: 0 },
+      { index: 2, match: "", mismatchPositions: [], numMismatches: 0 },
+      { index: 3, match: "", mismatchPositions: [], numMismatches: 0 },
+      { index: 4, match: "", mismatchPositions: [], numMismatches: 0 }
+    ]);
+
+    // Empty target sequence
+    expect(findApproxMatches("ATG", "", 0)).toEqual([]);
+
+    // Search sequence longer than target
+    expect(findApproxMatches("ATGCG", "ATGC", 0)).toEqual([]);
+
+    // Exactly matching length sequences
+    expect(findApproxMatches("ATGC", "ATGC", 0)).toEqual([
+      { index: 0, match: "ATGC", mismatchPositions: [], numMismatches: 0 }
+    ]);
+
+    // Sequences with special characters
+    expect(findApproxMatches("AT-G", "AT-GC", 0)).toEqual([
+      { index: 0, match: "AT-G", mismatchPositions: [], numMismatches: 0 }
+    ]);
+  });
+
+  it("handles larger sequences efficiently", () => {
+    const longTarget = "ATGCGATCGATCGATCGATCGATCGATCGATCG";
+    const longSearch = "ATCGATCG";
+
+    // The actual positions where the pattern appears in the sequence
+    const expected = [
+      { index: 5, match: "ATCGATCG", mismatchPositions: [], numMismatches: 0 },
+      { index: 9, match: "ATCGATCG", mismatchPositions: [], numMismatches: 0 },
+      { index: 13, match: "ATCGATCG", mismatchPositions: [], numMismatches: 0 },
+      { index: 17, match: "ATCGATCG", mismatchPositions: [], numMismatches: 0 },
+      { index: 21, match: "ATCGATCG", mismatchPositions: [], numMismatches: 0 },
+      { index: 25, match: "ATCGATCG", mismatchPositions: [], numMismatches: 0 }
+    ];
+
+    // Only include indices where we have full matches (length of search string)
+    const actual = findApproxMatches(longSearch, longTarget, 0).filter(
+      m => m.match.length === longSearch.length
+    );
+
+    expect(actual).toEqual(expected);
+  });
+
+  it("tracks exact positions of mismatches", () => {
+    // Test specific positions of mismatches
+    const result = findApproxMatches("ATGCTA", "ATCCAA", 2);
+
+    expect(result).toEqual([
+      {
+        index: 0,
+        match: "ATCCAA",
+        mismatchPositions: [2, 4],
+        numMismatches: 2
+      }
+    ]);
+  });
+});

package/src/index.js

@@ -40,6 +40,7 @@ export { default as getDegenerateRnaStringFromAAString } from "./getDegenerateRn
 export { default as getVirtualDigest } from "./getVirtualDigest";
 export { default as isEnzymeType2S } from "./isEnzymeType2S";
 export { default as insertGapsIntoRefSeq } from "./insertGapsIntoRefSeq";
+export { default as findApproxMatches } from "./findApproxMatches";
 export { default as adjustBpsToReplaceOrInsert } from "./adjustBpsToReplaceOrInsert";
 export { default as calculatePercentGC } from "./calculatePercentGC";
 export { default as calculateTm } from "./calculateTm";