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

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

@@ -1,22 +1,34 @@
 import calculateTm from "./calculateNebTm";
 
+interface NebTaOptions {
+  monovalentCationConc?: number;
+  polymerase?: string;
+}
+
 export default function calculateNebTa(
-  sequences,
-  primerConc,
-  { monovalentCationConc, polymerase } = {}
-) {
+  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`
       );
     }
-    const meltingTemperatures = sequences.map(seq =>
-      calculateTm(seq, primerConc, { monovalentCationConc })
-    );
+    // 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;
+    let annealingTemp: number;
     if (polymerase === "Q5") {
       // Ta = Tm_lower+1°C is standard for Q5
       annealingTemp = lowerMeltingTemp + 1;

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

@@ -7,10 +7,16 @@ import calculatePercentGc from "./calculatePercentGC";
 // - salt correction (for monovalent cations): Owczarzy (2004) Biochem 43:3537-54
 
 // primer concentration & monovalent cation concentration in M
+
+interface NebTmOptions {
+  monovalentCationConc?: number;
+  primerConc?: number;
+}
+
 export default function calculateNebTm(
-  sequence,
-  { monovalentCationConc = 0.05, primerConc = 0.0000005 } = {}
-) {
+  sequence: string,
+  { monovalentCationConc = 0.05, primerConc = 0.0000005 }: NebTmOptions = {}
+): number | string {
   try {
     const checkForDegenerateBases = /[^atgc]/i.test(sequence);
     if (checkForDegenerateBases) {
@@ -32,7 +38,7 @@ export default function calculateNebTm(
     const celsiusToKelvin = 273.15;
     // to convert the units of enthalpy from kilocal/mol to cal/mol
     const kilocalToCal = 1000;
-    const sequenceToEnthalpyMap = {
+    const sequenceToEnthalpyMap: Record<string, number> = {
       "AA/TT": -7.9,
       "AT/TA": -7.2,
       "TA/AT": -7.2,
@@ -52,7 +58,7 @@ export default function calculateNebTm(
       initiationWithTerminalGC: 0.1,
       initiationWithTerminalAT: 2.3
     };
-    const sequenceToEntropyMap = {
+    const sequenceToEntropyMap: Record<string, number> = {
       "AA/TT": -22.2,
       "AT/TA": -20.4,
       "TA/AT": -21.3,
@@ -76,11 +82,11 @@ export default function calculateNebTm(
       if (i === 0 || i === seq.length - 1) {
         // first or last nucleotide
         if (seq[i] === "G" || seq[i] === "C") {
-          hi += sequenceToEnthalpyMap.initiationWithTerminalGC;
-          si += sequenceToEntropyMap.initiationWithTerminalGC;
+          hi += sequenceToEnthalpyMap["initiationWithTerminalGC"];
+          si += sequenceToEntropyMap["initiationWithTerminalGC"];
         } else if (seq[i] === "A" || seq[i] === "T") {
-          hi += sequenceToEnthalpyMap.initiationWithTerminalAT;
-          si += sequenceToEntropyMap.initiationWithTerminalAT;
+          hi += sequenceToEnthalpyMap["initiationWithTerminalAT"];
+          si += sequenceToEntropyMap["initiationWithTerminalAT"];
         }
       }
       if (i < seq.length - 1) {

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

@@ -1,3 +1,3 @@
-export default function calculatePercentGC(bps) {
+export default function calculatePercentGC(bps: string): number {
   return ((bps.match(/[cg]/gi) || []).length / bps.length) * 100 || 0;
 }

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

@@ -19,6 +19,11 @@
  *   Proc Natl Acad Sci 95:1460-65
  */
 
+export interface SantaLuciaParams {
+  dH: number;
+  dS: number;
+}
+
 // Primer3 custom parameters (fixed)
 const PRIMER3_PARAMS = {
   saltMonovalent: 50.0, // mM
@@ -30,7 +35,7 @@ const PRIMER3_PARAMS = {
 
 // SantaLucia (1998) nearest-neighbor parameters
 // dH in kcal/mol, dS in cal/K·mol
-export const SANTA_LUCIA_NN = {
+export const SANTA_LUCIA_NN: Record<string, SantaLuciaParams> = {
   AA: { dH: -7.9, dS: -22.2 },
   TT: { dH: -7.9, dS: -22.2 },
   AT: { dH: -7.2, dS: -20.4 },
@@ -50,7 +55,7 @@ export const SANTA_LUCIA_NN = {
 };
 
 // Initiation parameters (SantaLucia 1998)
-export const SANTA_LUCIA_INIT = {
+export const SANTA_LUCIA_INIT: Record<string, SantaLuciaParams> = {
   GC: { dH: 0.1, dS: -2.8 }, // initiation with terminal GC
   AT: { dH: 2.3, dS: 4.1 } // initiation with terminal AT
 };
@@ -62,7 +67,7 @@ export const SANTA_LUCIA_INIT = {
  *
  * @returns {number} - Effective monovalent concentration in mM
  */
-function getEffectiveMonovalentConc() {
+function getEffectiveMonovalentConc(): number {
   let effectiveMono = PRIMER3_PARAMS.saltMonovalent;
 
   // Adjust for divalent cations
@@ -84,7 +89,7 @@ function getEffectiveMonovalentConc() {
  * @param {number} nnPairs - Number of nearest-neighbor pairs
  * @returns {number} - Corrected entropy in cal/K·mol
  */
-function applySaltCorrection(deltaS, nnPairs) {
+function applySaltCorrection(deltaS: number, nnPairs: number): number {
   const effectiveMono = getEffectiveMonovalentConc();
   // SantaLucia (1998) salt correction
   return deltaS + 0.368 * nnPairs * Math.log(effectiveMono / 1000);
@@ -96,7 +101,7 @@ function applySaltCorrection(deltaS, nnPairs) {
  * @param {string} sequence - DNA sequence
  * @returns {boolean} - True if valid
  */
-export function isValidSequence(sequence) {
+export function isValidSequence(sequence: string): boolean {
   return /^[ATGCN]+$/.test(sequence);
 }
 
@@ -107,16 +112,18 @@ export function isValidSequence(sequence) {
  * @returns {number} - Melting temperature in Celsius
  * @throws {Error} Invalid sequence or too short.
  */
-export default function calculateSantaLuciaTm(sequence) {
+export default function calculateSantaLuciaTm(
+  sequence: string
+): number | string {
   // Convert to uppercase and validate
   try {
-    sequence = sequence?.toUpperCase().trim();
+    const seq = sequence?.toUpperCase().trim();
 
-    if (!isValidSequence(sequence)) {
+    if (!isValidSequence(seq)) {
       throw new Error("Invalid sequence: contains non-DNA characters");
     }
 
-    if (sequence.length < 2) {
+    if (seq.length < 2) {
       throw new Error("Sequence too short: minimum length is 2 bases");
     }
 
@@ -124,8 +131,8 @@ export default function calculateSantaLuciaTm(sequence) {
     let deltaS = 0; // cal/K·mol
 
     // Calculate nearest-neighbor contributions
-    for (let i = 0; i < sequence.length - 1; i++) {
-      const dinucleotide = sequence.substring(i, i + 2);
+    for (let i = 0; i < seq.length - 1; i++) {
+      const dinucleotide = seq.substring(i, i + 2);
 
       // Skip if contains N
       if (dinucleotide.includes("N")) {
@@ -140,28 +147,28 @@ export default function calculateSantaLuciaTm(sequence) {
     }
 
     // Add initiation parameters
-    const firstBase = sequence[0];
-    const lastBase = sequence[sequence.length - 1];
+    const firstBase = seq[0];
+    const lastBase = seq[seq.length - 1];
 
     // Terminal GC or AT initiation
     if (firstBase === "G" || firstBase === "C") {
-      deltaH += SANTA_LUCIA_INIT.GC.dH;
-      deltaS += SANTA_LUCIA_INIT.GC.dS;
+      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;
+      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;
+      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;
+      deltaH += SANTA_LUCIA_INIT["AT"].dH;
+      deltaS += SANTA_LUCIA_INIT["AT"].dS;
     }
 
     // Apply salt correction
-    const nnPairs = sequence.length - 1;
+    const nnPairs = seq.length - 1;
     deltaS = applySaltCorrection(deltaS, nnPairs);
 
     // Calculate Tm using: Tm = deltaH / (deltaS + R * ln(C/4))

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

@@ -4,10 +4,19 @@
  * @author Nick Elsbree
  * @author Zinovii Dmytriv (original author)
  */
+
+interface CalculateTemperatureOptions {
+  type?: "breslauer" | "sugimoto" | "unified";
+  A?: number;
+  R?: number;
+  primerConc?: number;
+  monovalentCationConc?: number;
+}
+
 const calcTmMethods = {
-  TABLE_BRESLAUER: "breslauer",
-  TABLE_SUGIMOTO: "sugimoto",
-  TABLE_UNIFIED: "unified",
+  TABLE_BRESLAUER: "breslauer" as const,
+  TABLE_SUGIMOTO: "sugimoto" as const,
+  TABLE_UNIFIED: "unified" as const,
 
   A: -10.8, // Helix initiation for deltaS
   R: 1.987, // Gas constant (cal/(K*mol)).
@@ -24,22 +33,29 @@ const calcTmMethods = {
    * return - Temperature for the given sequence, in Celsius.
    */
   calculateTemperature: function (
-    _sequence,
-    { type, A, R, primerConc, monovalentCationConc } = {}
-  ) {
+    _sequence: string,
+    {
+      type,
+      A,
+      R,
+      primerConc,
+      monovalentCationConc
+    }: CalculateTemperatureOptions = {}
+  ): number {
     const sequence = (_sequence || "").toLowerCase();
     if (typeof type === "undefined") {
       // type = this.TABLE_SUGIMOTO  ;
       // type = this.TABLE_UNIFIED;
       type = this.TABLE_BRESLAUER;
     } else if (
-      type != this.TABLE_BRESLAUER &&
-      type != this.TABLE_UNIFIED &&
-      type != this.TABLE_SUGIMOTO
+      type !== this.TABLE_BRESLAUER &&
+      type !== this.TABLE_UNIFIED &&
+      type !== this.TABLE_SUGIMOTO
     ) {
       throw new Error("Invalid table type!");
     }
 
+    /* eslint-disable no-param-reassign */
     if (!A) {
       A = this.A;
     }
@@ -52,17 +68,23 @@ const calcTmMethods = {
     if (!monovalentCationConc) {
       monovalentCationConc = this.monovalentCationConc;
     }
+    /* eslint-enable no-param-reassign */
 
     const sequenceLength = sequence.length;
 
-    if (sequenceLength == 0) {
+    if (sequenceLength === 0) {
       return 0;
     }
 
     const deltaHTable = this.getDeltaHTable(type);
     const deltaSTable = this.getDeltaSTable(type);
 
-    const neighbors = []; // List goes in order: aa, at, ac, ag, tt, ta, tc, tg, cc, ca, ct, cg, gg, ga, gt, gc
+    if (!deltaHTable || !deltaSTable) {
+      // Should not happen if type validation passes
+      return 0;
+    }
+
+    const neighbors: number[] = []; // List goes in order: aa, at, ac, ag, tt, ta, tc, tg, cc, ca, ct, cg, gg, ga, gt, gc
 
     neighbors.push(this.calculateReps(sequence, "aa"));
     neighbors.push(this.calculateNumberOfOccurrences(sequence, "at"));
@@ -88,6 +110,7 @@ const calcTmMethods = {
     let sumDeltaS = 0.0;
 
     for (let i = 0; i < 16; i++) {
+      // Safe access as neighbors and tables are 16-length
       sumDeltaH = sumDeltaH + neighbors[i] * deltaHTable[i];
       sumDeltaS = sumDeltaS + neighbors[i] * deltaSTable[i];
     }
@@ -107,18 +130,18 @@ const calcTmMethods = {
    * @param {String} type Algorithm to get table for.
    * @return {Number[]} deltaH table for given algorithm.
    */
-  getDeltaHTable: function (type) {
-    if (type == this.TABLE_BRESLAUER) {
+  getDeltaHTable: function (type: string): number[] | null {
+    if (type === this.TABLE_BRESLAUER) {
       return [
         9.1, 8.6, 6.5, 7.8, 9.1, 6.0, 5.6, 5.8, 11.0, 5.8, 7.8, 11.9, 11.0, 5.6,
         6.5, 11.1
       ];
-    } else if (type == this.TABLE_SUGIMOTO) {
+    } else if (type === this.TABLE_SUGIMOTO) {
       return [
         8.0, 5.6, 6.5, 7.8, 8.0, 5.6, 5.6, 5.8, 10.9, 8.2, 6.6, 11.8, 10.9, 6.6,
         9.4, 11.9
       ];
-    } else if (type == this.TABLE_UNIFIED) {
+    } else if (type === this.TABLE_UNIFIED) {
       return [
         7.9, 7.2, 8.4, 7.8, 7.9, 7.2, 8.2, 8.5, 8.0, 8.5, 7.8, 10.6, 8.0, 8.2,
         8.4, 9.8
@@ -127,41 +150,6 @@ const calcTmMethods = {
       return null;
     }
   },
-  // "AA/TT": -7.9, 7.9
-  // "AT/TA": -7.2, 7.2
-  // "AC/TG": -8.4, 8.4
-  // "AG/TC": -7.8, 7.8
-  // "TT/AA": -7.9, 7.9
-  // "TA/AT": -7.2, 7.2
-  // "TG/AC": -8.5, 8.2
-  // "TC/AG": -8.2, 8.5
-  // "CC/GG": -8.0, 8.0
-  // "CA/GT": -8.5, 8.5
-  // "CT/GA": -7.8, 7.8
-  // "CG/GC": -10.6, 10.6
-  // "GG/CC": -8.0, 8.0
-  // "GA/CT": -8.2, 8.2,
-  // "GT/CA": -8.4, 8.4
-  // "GC/CG": -9.8, 9.8
-
-  // aa, at, ac, ag, tt, ta, tc, tg, cc, ca, ct, cg, gg, ga, gt, gc
-
-  // "AA/TT": -22.2,22.2,
-  // "AT/TA": -20.4,20.4,
-  // "AC/TG": -22.4,22.4,
-  // "AG/TC": -21.0,21.0,
-  // "TT/AA": -22.2,22.2,
-  // "TA/AT": -21.3,21.3,
-  // "TC/AG": -22.2,22.2,
-  // "TG/AC": -22.7,22.7,
-  // "CC/GG": -19.9,19.9,
-  // "CA/GT": -22.7,22.7,
-  // "CT/GA": -21.0,21.0,
-  // "CG/GC": -27.2,27.2,
-  // "GG/CC": -19.9,19.9,
-  // "GT/CA": -22.4,22.2,
-  // "GA/CT": -22.2,22.4,
-  // "GC/CG": -24.4,24.4
 
   /**
    * @private
@@ -169,18 +157,18 @@ const calcTmMethods = {
    * @param {String} type Algorithm to get table for.
    * @return {Number[]} deltaS table for given algorithm.
    */
-  getDeltaSTable: function (type) {
-    if (type == this.TABLE_BRESLAUER) {
+  getDeltaSTable: function (type: string): number[] | null {
+    if (type === this.TABLE_BRESLAUER) {
       return [
         24.0, 23.9, 17.3, 20.8, 24.0, 16.9, 13.5, 12.9, 26.6, 12.9, 20.8, 27.8,
         26.6, 13.5, 17.3, 26.7
       ];
-    } else if (type == this.TABLE_SUGIMOTO) {
+    } else if (type === this.TABLE_SUGIMOTO) {
       return [
         21.9, 15.2, 17.3, 20.8, 21.9, 15.2, 13.5, 12.9, 28.4, 25.5, 23.5, 29.0,
         28.4, 16.4, 25.5, 29.0
       ];
-    } else if (type == this.TABLE_UNIFIED) {
+    } else if (type === this.TABLE_UNIFIED) {
       return [
         22.2, 20.4, 22.4, 21.0, 22.2, 21.3, 22.2, 22.7, 19.9, 22.7, 21.0, 27.2,
         19.9, 22.2, 22.4, 24.4
@@ -199,10 +187,10 @@ const calcTmMethods = {
    * @param  {String} target   The string to search for.
    * @return {Int} Number of occurrences of target in sequence, with repeats.
    */
-  calculateReps: function (sequence, target) {
+  calculateReps: function (sequence: string, target: string): number {
     const sequenceLength = sequence.length;
 
-    if (sequenceLength == 0) {
+    if (sequenceLength === 0) {
       return 0;
     }
 
@@ -213,7 +201,7 @@ const calcTmMethods = {
     while (true) {
       const foundSeq = sequence.indexOf(target, seqOffset);
 
-      if (foundSeq == -1) {
+      if (foundSeq === -1) {
         break;
       }
 
@@ -235,10 +223,13 @@ const calcTmMethods = {
    * @param  {String} target   The string to search for.
    * @return {Int} Number of occurrences of target in sequence.
    */
-  calculateNumberOfOccurrences: function (sequence, target) {
+  calculateNumberOfOccurrences: function (
+    sequence: string,
+    target: string
+  ): number {
     const sequenceLength = sequence.length;
 
-    if (sequenceLength == 0) {
+    if (sequenceLength === 0) {
       return 0;
     }
 

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

@@ -5,8 +5,26 @@ import {
   getRangeLength
 } from "@teselagen/range-utils";
 import getCutsitesFromSequence from "./getCutsitesFromSequence";
+import { CutSite, DigestFragment, RestrictionEnzyme } from "./types";
 
-function computeDigestFragments({
+// Explicitly define the params interface
+export interface ComputeDigestFragmentsParams {
+  cutsites: CutSite[];
+  sequenceLength: number;
+  circular: boolean;
+  includeOverAndUnderHangs?: boolean;
+  computePartialDigest?: boolean;
+  computeDigestDisabled?: boolean;
+  computePartialDigestDisabled?: boolean;
+  selectionLayerUpdate?: (params: {
+    start: number;
+    end: number;
+    name: string;
+  }) => void;
+  updateSelectedFragment?: (id: string) => void;
+}
+
+export function computeDigestFragments({
   cutsites,
   sequenceLength,
   circular,
@@ -17,14 +35,17 @@ function computeDigestFragments({
   computePartialDigestDisabled,
   selectionLayerUpdate,
   updateSelectedFragment
-}) {
-  const fragments = [];
-  const overlappingEnzymes = [];
-  const pairs = [];
+}: ComputeDigestFragmentsParams) {
+  const fragments: DigestFragment[] = [];
+  const overlappingEnzymes: DigestFragment[] = [];
+  const pairs: CutSite[][] = [];
 
-  const sortedCutsites = cutsites.sort((a, b) => {
-    return a.topSnipPosition - b.topSnipPosition;
-  });
+  const sortedCutsites = cutsites.filter(
+    (
+      c
+    ): c is CutSite & { topSnipPosition: number; bottomSnipPosition: number } =>
+      c.topSnipPosition != null && c.bottomSnipPosition != null
+  );
   if (!circular && cutsites.length) {
     sortedCutsites.push({
       id: "seqTerm_" + shortid(),
@@ -33,6 +54,7 @@ function computeDigestFragments({
       overhangBps: "",
       topSnipPosition: 0,
       bottomSnipPosition: 0,
+      overhangSize: 0, // Added to satisfy CutSite
       upstreamTopSnip: 0,
       upstreamBottomSnip: 0,
       upstreamTopBeforeBottom: false,
@@ -43,21 +65,21 @@ function computeDigestFragments({
       },
       forward: true,
       name: "Sequence_Terminus",
+      type: "START_OR_END_OF_SEQ",
       restrictionEnzyme: {
-        name: "Sequence_Terminus"
+        name: "Sequence_Terminus",
+        site: "",
+        forwardRegex: "",
+        reverseRegex: ""
       }
     });
   }
 
+  sortedCutsites.sort((a, b) => {
+    return a.topSnipPosition - b.topSnipPosition;
+  });
+
   sortedCutsites.forEach((cutsite1, index) => {
-    if (computePartialDigest && !computePartialDigestDisabled) {
-      sortedCutsites.forEach((cs, index2) => {
-        if (index2 === index + 1 || index2 === 0) {
-          return;
-        }
-        pairs.push([cutsite1, sortedCutsites[index2]]);
-      });
-    }
     if (!computeDigestDisabled) {
       pairs.push([
         cutsite1,
@@ -66,36 +88,48 @@ function computeDigestFragments({
           : sortedCutsites[0]
       ]);
     }
+    if (computePartialDigest && !computePartialDigestDisabled) {
+      sortedCutsites.forEach((cs, index2) => {
+        // Filter out adjacent cutsites (standard digest handles these)
+        const isAdjacent =
+          index2 === index + 1 ||
+          (index === sortedCutsites.length - 1 && index2 === 0);
+        if (isAdjacent) {
+          return;
+        }
+        pairs.push([cutsite1, sortedCutsites[index2]]);
+      });
+    }
   });
 
   pairs.forEach(r => {
     let [cut1, cut2] = r;
 
-    let start;
-    let end;
-    let size;
+    let start: number;
+    let end: number;
+    let size: number;
     start = normalizePositionByRangeLength(
-      cut1.topSnipPosition,
+      cut1.topSnipPosition!,
       sequenceLength
     );
     end = normalizePositionByRangeLength(
-      cut2.topSnipPosition - 1,
+      cut2.topSnipPosition! - 1,
       sequenceLength
     );
     size = getRangeLength({ start, end }, sequenceLength);
-    let overlapsSelf;
+    let overlapsSelf: boolean | undefined;
     if (includeOverAndUnderHangs) {
       const oldSize = size;
       start = normalizePositionByRangeLength(
         cut1.topSnipBeforeBottom
-          ? cut1.topSnipPosition
-          : cut1.bottomSnipPosition,
+          ? cut1.topSnipPosition!
+          : cut1.bottomSnipPosition!,
         sequenceLength
       );
       end = normalizePositionByRangeLength(
         cut2.topSnipBeforeBottom
-          ? cut2.bottomSnipPosition - 1
-          : cut2.topSnipPosition - 1,
+          ? cut2.bottomSnipPosition! - 1
+          : cut2.topSnipPosition! - 1,
         sequenceLength
       );
       size = getRangeLength({ start, end }, sequenceLength);
@@ -106,7 +140,7 @@ function computeDigestFragments({
       }
     }
 
-    let isFormedFromLinearEnd;
+    let isFormedFromLinearEnd: boolean | undefined;
     if (cut1.name === "Sequence_Terminus") {
       cut1 = cloneDeep(cut1);
       isFormedFromLinearEnd = true;
@@ -119,13 +153,31 @@ function computeDigestFragments({
       cut2.restrictionEnzyme.name = "Linear_Sequence_End";
     }
 
+    // Add isOverhangIncludedInFragmentSize logic
+    cut1 = {
+      ...cut1,
+      isOverhangIncludedInFragmentSize:
+        cut1.name !== "Linear_Sequence_Start" &&
+        cut1.name !== "Sequence_Terminus" &&
+        (cut1.overhangSize || 0) > 0 &&
+        !!cut1.topSnipBeforeBottom
+    };
+    cut2 = {
+      ...cut2,
+      isOverhangIncludedInFragmentSize:
+        cut2.name !== "Linear_Sequence_End" &&
+        cut2.name !== "Sequence_Terminus" &&
+        (cut2.overhangSize || 0) > 0 &&
+        !cut2.topSnipBeforeBottom
+    };
+
     const id = start + "-" + end + "-" + size + "-";
     const name = `${cut1.restrictionEnzyme.name} -- ${cut2.restrictionEnzyme.name} ${size} bps`;
-    getRangeLength({ start, end }, sequenceLength);
+    // getRangeLength({ start, end }, sequenceLength);
 
     fragments.push({
       isFormedFromLinearEnd,
-      madeFromOneCutsite: cut1 === cut2,
+      madeFromOneCutsite: cut1.id === cut2.id,
       start,
       end,
       size,
@@ -163,20 +215,24 @@ function computeDigestFragments({
   };
 }
 
-function getDigestFragsForSeqAndEnzymes({
+export function getDigestFragsForSeqAndEnzymes({
   sequence,
   circular,
   enzymes,
   includeOverAndUnderHangs
+}: {
+  sequence: string;
+  circular: boolean;
+  enzymes: RestrictionEnzyme[];
+  includeOverAndUnderHangs?: boolean;
 }) {
   const cutsitesByName = getCutsitesFromSequence(sequence, circular, enzymes);
-  return computeDigestFragments({
+  const digest = computeDigestFragments({
     includeOverAndUnderHangs,
-    cutsites: flatMap(cutsitesByName),
+    cutsites: flatMap(cutsitesByName) as CutSite[],
     sequenceLength: sequence.length,
     circular
   });
+  digest.fragments.sort((a, b) => b.size - a.size);
+  return digest;
 }
-
-export { computeDigestFragments };
-export { getDigestFragsForSeqAndEnzymes };

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

@@ -1,8 +1,8 @@
 export default function condensePairwiseAlignmentDifferences(
-  referenceSeq,
-  alignedSeq
-) {
-  const overviewMinimapTrack = [];
+  referenceSeq: string,
+  alignedSeq: string
+): string {
+  const overviewMinimapTrack: string[] = [];
   const referenceSeqSplit = referenceSeq.toLowerCase().split("");
   const alignedSeqSplit = alignedSeq.toLowerCase().split("");
   const seqLength = alignedSeq.length;