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

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

@@ -1,4 +1,4 @@
-import { getRangeLength } from "@teselagen/range-utils";
+import { getRangeLength, Range } from "@teselagen/range-utils";
 import { map, cloneDeep } from "lodash-es";
 import convertDnaCaretPositionOrRangeToAa from "./convertDnaCaretPositionOrRangeToAA";
 import rotateSequenceDataToPosition from "./rotateSequenceDataToPosition";
@@ -7,13 +7,21 @@ import tidyUpSequenceData from "./tidyUpSequenceData";
 import { modifiableTypes } from "./annotationTypes";
 import adjustBpsToReplaceOrInsert from "./adjustBpsToReplaceOrInsert";
 import adjustAnnotationsToInsert from "./adjustAnnotationsToInsert";
+import { Annotation, ChromatogramData, SequenceData } from "./types";
+
+interface InsertSequenceDataOptions {
+  maintainOriginSplit?: boolean;
+  doNotRemoveInvalidChars?: boolean;
+  topLevelSeqData?: SequenceData;
+  [key: string]: unknown;
+}
 
 export default function insertSequenceDataAtPositionOrRange(
-  _sequenceDataToInsert,
-  _existingSequenceData,
-  caretPositionOrRange,
-  options = {}
-) {
+  _sequenceDataToInsert: SequenceData,
+  _existingSequenceData: SequenceData,
+  caretPositionOrRange: number | Range,
+  options: InsertSequenceDataOptions = {}
+): SequenceData {
   //maintainOriginSplit means that if you're inserting around the origin with n bps selected before the origin
   //when inserting new seq, n bps of the new seq should go in before the origin and the rest should be
   //inserted at the sequence start
@@ -31,13 +39,21 @@ export default function insertSequenceDataAtPositionOrRange(
     sequenceDataToInsert.isProtein && sequenceDataToInsert.proteinSequence
       ? sequenceDataToInsert.proteinSequence.length * 3
       : sequenceDataToInsert.sequence.length;
-  let caretPosition = caretPositionOrRange;
+  let caretPosition =
+    typeof caretPositionOrRange === "number"
+      ? caretPositionOrRange
+      : caretPositionOrRange.start;
 
   const isInsertSameLengthAsSelection =
+    typeof caretPositionOrRange !== "number" &&
     sequenceDataToInsert.sequence.length ===
-    getRangeLength(caretPositionOrRange, existingSequenceData.sequence.length);
+      getRangeLength(
+        caretPositionOrRange,
+        existingSequenceData.sequence.length
+      );
 
   if (
+    typeof caretPositionOrRange !== "number" &&
     caretPositionOrRange.start > -1 &&
     getRangeLength(
       caretPositionOrRange,
@@ -45,12 +61,18 @@ export default function insertSequenceDataAtPositionOrRange(
     ) === existingSequenceData.sequence.length
   ) {
     //handle the case where we're deleting everything!
+    const emptyAnnotations = modifiableTypes.reduce(
+      (acc, type) => {
+        acc[type] = [];
+        return acc;
+      },
+      {} as Record<string, Annotation[]>
+    );
+
     existingSequenceData = tidyUpSequenceData(
       {
         ...existingSequenceData,
-        ...modifiableTypes.reduce((acc, type) => {
-          return (acc[type] = []);
-        }, {}),
+        ...emptyAnnotations,
         sequence: "",
         doNotRemoveInvalidChars: true,
         proteinSequence: "",
@@ -64,7 +86,10 @@ export default function insertSequenceDataAtPositionOrRange(
     newSequenceData.chromatogramData.baseTraces
   ) {
     //handle chromatogramData updates
-    if (caretPositionOrRange && caretPositionOrRange.start > -1) {
+    if (
+      typeof caretPositionOrRange !== "number" &&
+      caretPositionOrRange.start > -1
+    ) {
       if (caretPositionOrRange.start > caretPositionOrRange.end) {
         newSequenceData.chromatogramData = trimChromatogram({
           chromatogramData: newSequenceData.chromatogramData,
@@ -74,14 +99,16 @@ export default function insertSequenceDataAtPositionOrRange(
           },
           justBaseCalls: isInsertSameLengthAsSelection
         });
-        newSequenceData.chromatogramData = trimChromatogram({
-          chromatogramData: newSequenceData.chromatogramData,
-          range: {
-            start: 0,
-            end: caretPositionOrRange.end
-          },
-          justBaseCalls: isInsertSameLengthAsSelection
-        });
+        if (newSequenceData.chromatogramData) {
+          newSequenceData.chromatogramData = trimChromatogram({
+            chromatogramData: newSequenceData.chromatogramData,
+            range: {
+              start: 0,
+              end: caretPositionOrRange.end
+            },
+            justBaseCalls: isInsertSameLengthAsSelection
+          });
+        }
       } else {
         newSequenceData.chromatogramData = trimChromatogram({
           chromatogramData: newSequenceData.chromatogramData,
@@ -93,13 +120,14 @@ export default function insertSequenceDataAtPositionOrRange(
         });
       }
     }
-    if (sequenceDataToInsert.sequence) {
+    if (sequenceDataToInsert.sequence && newSequenceData.chromatogramData) {
       insertIntoChromatogram({
         chromatogramData: newSequenceData.chromatogramData,
         caretPosition:
+          typeof caretPositionOrRange !== "number" &&
           caretPositionOrRange.start > -1
             ? caretPositionOrRange.start
-            : caretPositionOrRange,
+            : (caretPositionOrRange as number),
         seqToInsert: sequenceDataToInsert.sequence,
         justBaseCalls: isInsertSameLengthAsSelection
       });
@@ -114,18 +142,25 @@ export default function insertSequenceDataAtPositionOrRange(
   );
   newSequenceData.size = newSequenceData.sequence.length;
   newSequenceData.proteinSequence = adjustBpsToReplaceOrInsert(
-    existingSequenceData.proteinSequence,
-    sequenceDataToInsert.proteinSequence,
+    existingSequenceData.proteinSequence || "",
+    sequenceDataToInsert.proteinSequence || "",
     convertDnaCaretPositionOrRangeToAa(caretPositionOrRange)
   );
-  newSequenceData.proteinSize = newSequenceData.proteinSequence.length;
+  newSequenceData.proteinSize = (newSequenceData.proteinSequence || "").length;
 
   //handle the insert
   modifiableTypes.forEach(annotationType => {
-    let existingAnnotations = existingSequenceData[annotationType];
+    let existingAnnotations = existingSequenceData[
+      annotationType
+    ] as Annotation[];
+    if (!existingAnnotations) return;
+
     //update the annotations:
     //handle the delete if necessary
-    if (caretPositionOrRange && caretPositionOrRange.start > -1) {
+    if (
+      typeof caretPositionOrRange !== "number" &&
+      caretPositionOrRange.start > -1
+    ) {
       //we have a range! so let's delete it!
       const range = caretPositionOrRange;
       caretPosition = range.start > range.end ? 0 : range.start;
@@ -138,25 +173,35 @@ export default function insertSequenceDataAtPositionOrRange(
     }
     //first clear the newSequenceData's annotations
     newSequenceData[annotationType] = [];
+    const annotationsToInsert = sequenceDataToInsert[
+      annotationType
+    ] as Annotation[];
     //in two steps adjust the annotations to the insert
-    newSequenceData[annotationType] = newSequenceData[annotationType].concat(
-      adjustAnnotationsToInsert(
-        existingAnnotations,
-        caretPosition,
-        insertLength
-      )
-    );
-    newSequenceData[annotationType] = newSequenceData[annotationType].concat(
-      adjustAnnotationsToInsert(
-        sequenceDataToInsert[annotationType],
-        0,
-        caretPosition
-      )
-    );
+    if (newSequenceData[annotationType]) {
+      // Explicitly cast to unknown array inside concat to avoid TS errors with specific Annotation types if they diverge slightly,
+      // though strictly they should be Annotation[]
+      (newSequenceData[annotationType] as Annotation[]) = (
+        newSequenceData[annotationType] as Annotation[]
+      ).concat(
+        adjustAnnotationsToInsert(
+          existingAnnotations,
+          caretPosition,
+          insertLength
+        )
+      );
+      if (annotationsToInsert) {
+        (newSequenceData[annotationType] as Annotation[]) = (
+          newSequenceData[annotationType] as Annotation[]
+        ).concat(
+          adjustAnnotationsToInsert(annotationsToInsert, 0, caretPosition)
+        );
+      }
+    }
   });
+
   if (
     maintainOriginSplit &&
-    caretPositionOrRange &&
+    typeof caretPositionOrRange !== "number" &&
     caretPositionOrRange.start > caretPositionOrRange.end
   ) {
     //we're replacing around the origin and maintainOriginSplit=true
@@ -171,7 +216,11 @@ export default function insertSequenceDataAtPositionOrRange(
   return newSequenceData;
 }
 
-function adjustAnnotationsToDelete(annotationsToBeAdjusted, range, maxLength) {
+function adjustAnnotationsToDelete(
+  annotationsToBeAdjusted: Annotation[],
+  range: Range,
+  maxLength: number
+): Annotation[] {
   return map(annotationsToBeAdjusted, annotation => {
     const newRange = adjustRangeToDeletionOfAnotherRange(
       annotation,
@@ -183,6 +232,10 @@ function adjustAnnotationsToDelete(annotationsToBeAdjusted, range, maxLength) {
       annotation.locations
         .map(loc => adjustRangeToDeletionOfAnotherRange(loc, range, maxLength))
         .filter(range => !!range);
+
+    // Check if newRange is valid (start/end exist) before returning
+    if (!newRange) return null;
+
     if (newLocations && newLocations.length) {
       return {
         ...newRange,
@@ -193,7 +246,7 @@ function adjustAnnotationsToDelete(annotationsToBeAdjusted, range, maxLength) {
     } else {
       return newRange;
     }
-  }).filter(range => !!range); //filter any fully deleted ranges
+  }).filter((range): range is Annotation => !!range); //filter any fully deleted ranges
 }
 
 function insertIntoChromatogram({
@@ -201,22 +254,28 @@ function insertIntoChromatogram({
   caretPosition,
   seqToInsert,
   justBaseCalls
-}) {
+}: {
+  chromatogramData: ChromatogramData;
+  caretPosition: number;
+  seqToInsert: string;
+  justBaseCalls?: boolean;
+}): ChromatogramData | void {
   if (!seqToInsert.length) return;
 
-  chromatogramData.baseCalls &&
-    chromatogramData.baseCalls.splice(
+  if (chromatogramData.baseCalls) {
+    (chromatogramData.baseCalls as unknown[]).splice(
       caretPosition,
       0,
       ...seqToInsert.split("")
     );
+  }
   if (justBaseCalls) {
     //return early if just base calls
     return chromatogramData;
   }
 
-  const baseTracesToInsert = [];
-  const qualNumsToInsert = [];
+  const baseTracesToInsert: unknown[] = [];
+  const qualNumsToInsert: number[] = [];
 
   for (let index = 0; index < seqToInsert.length; index++) {
     qualNumsToInsert.push(0);
@@ -229,10 +288,20 @@ function insertIntoChromatogram({
     });
   }
 
-  chromatogramData.baseTraces &&
-    chromatogramData.baseTraces.splice(caretPosition, 0, ...baseTracesToInsert);
-  chromatogramData.qualNums &&
-    chromatogramData.qualNums.splice(caretPosition, 0, ...qualNumsToInsert);
+  if (chromatogramData.baseTraces) {
+    (chromatogramData.baseTraces as unknown[]).splice(
+      caretPosition,
+      0,
+      ...baseTracesToInsert
+    );
+  }
+  if (chromatogramData.qualNums) {
+    (chromatogramData.qualNums as unknown[]).splice(
+      caretPosition,
+      0,
+      ...qualNumsToInsert
+    );
+  }
 
   return chromatogramData;
 }
@@ -241,13 +310,18 @@ function trimChromatogram({
   chromatogramData,
   range: { start, end },
   justBaseCalls
-}) {
+}: {
+  chromatogramData: ChromatogramData;
+  range: { start: number; end: number };
+  justBaseCalls?: boolean;
+}): ChromatogramData {
   [
     "baseCalls",
     ...(justBaseCalls ? [] : ["qualNums", "baseTraces", "basePos"])
   ].forEach(type => {
-    chromatogramData[type] &&
-      chromatogramData[type].splice(start, end - start + 1);
+    if (chromatogramData[type]) {
+      (chromatogramData[type] as unknown[]).splice(start, end - start + 1);
+    }
   });
 
   return chromatogramData;

package/src/isEnzymeType2S.ts

@@ -0,0 +1,5 @@
+import { RestrictionEnzyme } from "./types";
+
+export default function isEnzymeType2S(e: RestrictionEnzyme) {
+  return e.site.length < e.topSnipOffset || e.site.length < e.bottomSnipOffset;
+}

package/src/mapAnnotationsToRows.ts

@@ -0,0 +1,256 @@
+import { each, forEach, startsWith, filter } from "lodash-es";
+import {
+  getYOffsetForPotentiallyCircularRange,
+  splitRangeIntoTwoPartsIfItIsCircular,
+  checkIfPotentiallyCircularRangesOverlap
+} from "@teselagen/range-utils";
+import { Annotation } from "./types";
+
+export interface MappedAnnotation extends Annotation {
+  yOffset?: number;
+  enclosingRangeType?: "beginning" | "end" | "beginningAndEnd";
+  annotation?: Annotation;
+}
+
+export default function mapAnnotationsToRows(
+  annotations: Annotation[],
+  sequenceLength: number,
+  bpsPerRow: number,
+  { splitForwardReverse }: { splitForwardReverse?: boolean } = {}
+) {
+  const annotationsToRowsMap: Record<number | string, MappedAnnotation[]> = {};
+  const yOffsetLevelMap: Record<
+    string | number,
+    { start: number; end: number }[][]
+  > = {};
+  const wrappedAnnotations: Record<string, boolean> = {};
+
+  each(annotations, annotation => {
+    const containsLocations = !!(
+      annotation.locations && annotation.locations.length
+    );
+    if (annotation.overlapsSelf) {
+      if (!wrappedAnnotations[annotation.id as string]) {
+        mapAnnotationToRows({
+          wrappedAnnotations,
+          annotation: {
+            ...annotation,
+            start: 0,
+            end: sequenceLength - 1,
+            id: `__tempAnnRemoveMe__${annotation.id}`,
+            overlapsSelf: false
+          },
+          sequenceLength,
+          bpsPerRow,
+          annotationsToRowsMap,
+          yOffsetLevelMap,
+          containsLocations,
+          splitForwardReverse
+        });
+        wrappedAnnotations[annotation.id as string] = true;
+      }
+    }
+
+    mapAnnotationToRows({
+      wrappedAnnotations,
+      annotation,
+      sequenceLength,
+      bpsPerRow,
+      annotationsToRowsMap,
+      yOffsetLevelMap,
+      containsLocations,
+      splitForwardReverse
+    });
+
+    if (containsLocations) {
+      annotation.locations?.forEach(location => {
+        mapAnnotationToRows({
+          wrappedAnnotations,
+          annotation,
+          sequenceLength,
+          bpsPerRow,
+          annotationsToRowsMap,
+          yOffsetLevelMap,
+          location: location as Annotation,
+          splitForwardReverse
+        });
+      });
+    }
+  });
+
+  forEach(annotationsToRowsMap, (annotationsForRow, i) => {
+    annotationsToRowsMap[i] = filter(
+      annotationsForRow,
+      ann => !startsWith(String(ann.id), "__tempAnnRemoveMe__")
+    );
+  });
+  return annotationsToRowsMap;
+}
+
+interface MapAnnotationToRowsParams {
+  wrappedAnnotations: Record<string, boolean>;
+  annotation: Annotation;
+  sequenceLength: number;
+  bpsPerRow: number;
+  annotationsToRowsMap: Record<number | string, MappedAnnotation[]>;
+  yOffsetLevelMap: Record<string | number, { start: number; end: number }[][]>;
+  location?: Annotation;
+  containsLocations?: boolean;
+  splitForwardReverse?: boolean;
+}
+
+function mapAnnotationToRows({
+  annotation,
+  sequenceLength,
+  bpsPerRow,
+  annotationsToRowsMap,
+  yOffsetLevelMap,
+  location,
+  containsLocations,
+  splitForwardReverse
+}: MapAnnotationToRowsParams) {
+  const ranges = splitRangeIntoTwoPartsIfItIsCircular(
+    location || annotation,
+    sequenceLength
+  );
+
+  ranges.forEach((range, index) => {
+    const startingRow = Math.floor(range.start / bpsPerRow);
+    const endingRow = Math.floor(range.end / bpsPerRow);
+
+    for (let rowNumber = startingRow; rowNumber <= endingRow; rowNumber++) {
+      if (!annotationsToRowsMap[rowNumber]) {
+        annotationsToRowsMap[rowNumber] = [];
+      }
+      const key = splitForwardReverse
+        ? annotation.forward
+          ? rowNumber + "_forward"
+          : rowNumber + "_reverse"
+        : rowNumber;
+
+      const annotationsForRow = annotationsToRowsMap[rowNumber];
+      if (!yOffsetLevelMap[key]) {
+        yOffsetLevelMap[key] = [];
+      }
+
+      let yOffset: number | undefined;
+      const yOffsetsForRow = yOffsetLevelMap[key];
+      const start =
+        rowNumber === startingRow ? range.start : rowNumber * bpsPerRow;
+      const end =
+        rowNumber === endingRow
+          ? range.end
+          : rowNumber * bpsPerRow + bpsPerRow - 1;
+
+      if (annotation.overlapsSelf) {
+        annotationsForRow.forEach(ann => {
+          if (ann.id === `__tempAnnRemoveMe__${annotation.id}`) {
+            yOffset = ann.yOffset;
+          }
+        });
+        if (yOffset === undefined) {
+          annotationsForRow.forEach(ann => {
+            if (ann.id === annotation.id) {
+              yOffset = ann.yOffset;
+            }
+          });
+        }
+      } else {
+        if (location) {
+          annotationsForRow.forEach(ann => {
+            if (ann.id === annotation.id) {
+              yOffset = ann.yOffset;
+            }
+          });
+        } else {
+          if (
+            index > 0 &&
+            annotationsForRow.length &&
+            annotationsForRow[annotationsForRow.length - 1].annotation ===
+              annotation
+          ) {
+            yOffset = annotationsForRow[annotationsForRow.length - 1].yOffset;
+          } else {
+            const siblingRangesOnThisRow = ranges.slice(index + 1).filter(r => {
+              const rStartRow = Math.floor(r.start / bpsPerRow);
+              const rEndRow = Math.floor(r.end / bpsPerRow);
+              return rowNumber >= rStartRow && rowNumber <= rEndRow;
+            });
+
+            if (siblingRangesOnThisRow.length > 0) {
+              // We have future ranges for this annotation on this row.
+              // We must choose a yOffset that works for the current range AND all future ranges.
+              let foundYOffset = -1;
+              yOffsetsForRow.some((rangesAlreadyAddedToYOffset, levelIndex) => {
+                const rangeBlocked = rangesAlreadyAddedToYOffset.some(
+                  comparisonRange => {
+                    return checkIfPotentiallyCircularRangesOverlap(
+                      range,
+                      comparisonRange
+                    );
+                  }
+                );
+                if (rangeBlocked) return false;
+
+                // Check siblings
+                const siblingBlocked = siblingRangesOnThisRow.some(
+                  siblingRange => {
+                    return rangesAlreadyAddedToYOffset.some(comparisonRange => {
+                      return checkIfPotentiallyCircularRangesOverlap(
+                        siblingRange,
+                        comparisonRange
+                      );
+                    });
+                  }
+                );
+
+                if (!siblingBlocked) {
+                  foundYOffset = levelIndex;
+                  return true;
+                }
+                return false;
+              });
+
+              if (foundYOffset > -1) {
+                yOffset = foundYOffset;
+                yOffsetsForRow[foundYOffset].push(range);
+              } else {
+                // Create new level
+                yOffset = yOffsetsForRow.length;
+                yOffsetsForRow.push([range]);
+              }
+            } else {
+              yOffset = getYOffsetForPotentiallyCircularRange(
+                range,
+                yOffsetsForRow,
+                false
+              );
+            }
+          }
+          if (yOffset !== undefined) {
+            if (!yOffsetsForRow[yOffset]) yOffsetsForRow[yOffset] = [];
+            yOffsetsForRow[yOffset].push({
+              start: start,
+              end: end
+            });
+          }
+        }
+      }
+
+      annotationsForRow.push({
+        ...annotation,
+        id: annotation.id,
+        annotation: annotation,
+        start: start,
+        end: end,
+        ...(containsLocations && { containsLocations }),
+        ...(location && { isJoinedLocation: !!location }),
+        yOffset: yOffset,
+        enclosingRangeType: range.type as
+          | "beginning"
+          | "end"
+          | "beginningAndEnd"
+      });
+    }
+  });
+}

package/src/prepareCircularViewData.ts

@@ -0,0 +1,24 @@
+import { cloneDeep } from "lodash-es";
+import { getYOffsetsForPotentiallyCircularRanges } from "@teselagen/range-utils";
+import { annotationTypes } from "./annotationTypes";
+import { SequenceData, Annotation } from "./types";
+
+//basically just adds yOffsets to the annotations
+export default function prepareCircularViewData(sequenceData: SequenceData) {
+  const clonedSeqData = cloneDeep(sequenceData);
+  annotationTypes.forEach(annotationType => {
+    if (annotationType !== "cutsites") {
+      const annotations = clonedSeqData[annotationType] as Annotation[];
+      if (annotations) {
+        const maxYOffset = getYOffsetsForPotentiallyCircularRanges(
+          annotations,
+          true
+        ).maxYOffset;
+        (
+          clonedSeqData[annotationType] as Annotation[] & { maxYOffset: number }
+        ).maxYOffset = maxYOffset;
+      }
+    }
+  });
+  return clonedSeqData;
+}

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

@@ -1,17 +1,31 @@
-// ac.throw([ac.posInt, ac.posInt, ac.bool], arguments);
-import mapAnnotationsToRows from "./mapAnnotationsToRows";
+import mapAnnotationsToRows, { MappedAnnotation } from "./mapAnnotationsToRows";
 
 import { annotationTypes } from "./annotationTypes";
 
-export default function prepareRowData(sequenceData, bpsPerRow) {
-  // ac.throw([ac.sequenceData, ac.posInt], arguments);
+import { SequenceData, Annotation } from "./types";
+
+export interface RowData {
+  rowNumber: number;
+  start: number;
+  end: number;
+  sequence: string;
+  [key: string]: MappedAnnotation[] | number | string;
+}
+
+export default function prepareRowData(
+  sequenceData: SequenceData,
+  bpsPerRow: number
+) {
   const sequenceLength = sequenceData.sequence.length;
   const totalRows = Math.ceil(sequenceLength / bpsPerRow) || 1; //this check makes sure there is always at least 1 row!
-  const rows = [];
-  const rowMap = {};
+  const rows: RowData[] = [];
+  const rowMap: Record<
+    string,
+    Record<string | number, MappedAnnotation[]>
+  > = {};
   annotationTypes.forEach(type => {
     rowMap[type] = mapAnnotationsToRows(
-      sequenceData[type],
+      (sequenceData[type] as Annotation[]) || [],
       sequenceLength,
       bpsPerRow,
       { splitForwardReverse: type === "primers" }
@@ -19,7 +33,12 @@ export default function prepareRowData(sequenceData, bpsPerRow) {
   });
 
   for (let rowNumber = 0; rowNumber < totalRows; rowNumber++) {
-    const row = {};
+    const row: RowData = {
+      rowNumber,
+      start: 0,
+      end: 0,
+      sequence: ""
+    };
     row.rowNumber = rowNumber;
     row.start = rowNumber * bpsPerRow;
     row.end =

package/src/prepareRowData_output1.json

@@ -138,6 +138,7 @@
         },
         "start": 1,
         "end": 3,
+        "forward": true,
         "yOffset": 0,
         "enclosingRangeType": "beginningAndEnd"
       }

package/src/rotateBpsToPosition.ts

@@ -0,0 +1,12 @@
+export default function rotateBpsToPosition(
+  bps: string,
+  caretPosition: number
+) {
+  return arrayRotate(bps.split(""), caretPosition).join("");
+}
+
+function arrayRotate<T>(arr: T[], count: number): T[] {
+  count -= arr.length * Math.floor(count / arr.length);
+  arr.push(...arr.splice(0, count));
+  return arr;
+}