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

package/src/insertSequenceDataAtPositionOrRange.ts

@@ -0,0 +1,328 @@
+import { getRangeLength, Range } from "@teselagen/range-utils";
+import { map, cloneDeep } from "lodash-es";
+import convertDnaCaretPositionOrRangeToAa from "./convertDnaCaretPositionOrRangeToAA";
+import rotateSequenceDataToPosition from "./rotateSequenceDataToPosition";
+import { adjustRangeToDeletionOfAnotherRange } from "@teselagen/range-utils";
+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: 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
+  const { maintainOriginSplit } = options;
+  let existingSequenceData = tidyUpSequenceData(_existingSequenceData, {
+    doNotRemoveInvalidChars: true,
+    ...options
+  });
+  const sequenceDataToInsert = tidyUpSequenceData(_sequenceDataToInsert, {
+    topLevelSeqData: existingSequenceData,
+    ...options
+  });
+  const newSequenceData = cloneDeep(existingSequenceData);
+  const insertLength =
+    sequenceDataToInsert.isProtein && sequenceDataToInsert.proteinSequence
+      ? sequenceDataToInsert.proteinSequence.length * 3
+      : sequenceDataToInsert.sequence.length;
+  let caretPosition =
+    typeof caretPositionOrRange === "number"
+      ? caretPositionOrRange
+      : caretPositionOrRange.start;
+
+  const isInsertSameLengthAsSelection =
+    typeof caretPositionOrRange !== "number" &&
+    sequenceDataToInsert.sequence.length ===
+      getRangeLength(
+        caretPositionOrRange,
+        existingSequenceData.sequence.length
+      );
+
+  if (
+    typeof caretPositionOrRange !== "number" &&
+    caretPositionOrRange.start > -1 &&
+    getRangeLength(
+      caretPositionOrRange,
+      existingSequenceData.sequence.length
+    ) === 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,
+        ...emptyAnnotations,
+        sequence: "",
+        doNotRemoveInvalidChars: true,
+        proteinSequence: "",
+        chromatogramData: undefined
+      },
+      options
+    );
+    newSequenceData.chromatogramData = undefined;
+  } else if (
+    newSequenceData.chromatogramData &&
+    newSequenceData.chromatogramData.baseTraces
+  ) {
+    //handle chromatogramData updates
+    if (
+      typeof caretPositionOrRange !== "number" &&
+      caretPositionOrRange.start > -1
+    ) {
+      if (caretPositionOrRange.start > caretPositionOrRange.end) {
+        newSequenceData.chromatogramData = trimChromatogram({
+          chromatogramData: newSequenceData.chromatogramData,
+          range: {
+            start: caretPositionOrRange.start,
+            end: newSequenceData.sequence.length
+          },
+          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,
+          range: {
+            start: caretPositionOrRange.start,
+            end: caretPositionOrRange.end
+          },
+          justBaseCalls: isInsertSameLengthAsSelection
+        });
+      }
+    }
+    if (sequenceDataToInsert.sequence && newSequenceData.chromatogramData) {
+      insertIntoChromatogram({
+        chromatogramData: newSequenceData.chromatogramData,
+        caretPosition:
+          typeof caretPositionOrRange !== "number" &&
+          caretPositionOrRange.start > -1
+            ? caretPositionOrRange.start
+            : (caretPositionOrRange as number),
+        seqToInsert: sequenceDataToInsert.sequence,
+        justBaseCalls: isInsertSameLengthAsSelection
+      });
+    }
+  }
+
+  //update the sequence
+  newSequenceData.sequence = adjustBpsToReplaceOrInsert(
+    existingSequenceData.sequence,
+    sequenceDataToInsert.sequence,
+    caretPositionOrRange
+  );
+  newSequenceData.size = newSequenceData.sequence.length;
+  newSequenceData.proteinSequence = adjustBpsToReplaceOrInsert(
+    existingSequenceData.proteinSequence || "",
+    sequenceDataToInsert.proteinSequence || "",
+    convertDnaCaretPositionOrRangeToAa(caretPositionOrRange)
+  );
+  newSequenceData.proteinSize = (newSequenceData.proteinSequence || "").length;
+
+  //handle the insert
+  modifiableTypes.forEach(annotationType => {
+    let existingAnnotations = existingSequenceData[
+      annotationType
+    ] as Annotation[];
+    if (!existingAnnotations) return;
+
+    //update the annotations:
+    //handle the delete if necessary
+    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;
+      //update all annotations for the deletion
+      existingAnnotations = adjustAnnotationsToDelete(
+        existingAnnotations,
+        range,
+        existingSequenceData.sequence.length
+      );
+    }
+    //first clear the newSequenceData's annotations
+    newSequenceData[annotationType] = [];
+    const annotationsToInsert = sequenceDataToInsert[
+      annotationType
+    ] as Annotation[];
+    //in two steps adjust the annotations to the insert
+    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 &&
+    typeof caretPositionOrRange !== "number" &&
+    caretPositionOrRange.start > caretPositionOrRange.end
+  ) {
+    //we're replacing around the origin and maintainOriginSplit=true
+    //so rotate the resulting seqData n bps
+    const caretPosToRotateTo =
+      existingSequenceData.sequence.length - caretPositionOrRange.start;
+    return rotateSequenceDataToPosition(
+      newSequenceData,
+      Math.min(caretPosToRotateTo, insertLength)
+    );
+  }
+  return newSequenceData;
+}
+
+function adjustAnnotationsToDelete(
+  annotationsToBeAdjusted: Annotation[],
+  range: Range,
+  maxLength: number
+): Annotation[] {
+  return map(annotationsToBeAdjusted, annotation => {
+    const newRange = adjustRangeToDeletionOfAnotherRange(
+      annotation,
+      range,
+      maxLength
+    );
+    const newLocations =
+      annotation.locations &&
+      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,
+        start: newLocations[0].start,
+        end: newLocations[newLocations.length - 1].end,
+        ...(newLocations.length > 0 && { locations: newLocations })
+      };
+    } else {
+      return newRange;
+    }
+  }).filter((range): range is Annotation => !!range); //filter any fully deleted ranges
+}
+
+function insertIntoChromatogram({
+  chromatogramData,
+  caretPosition,
+  seqToInsert,
+  justBaseCalls
+}: {
+  chromatogramData: ChromatogramData;
+  caretPosition: number;
+  seqToInsert: string;
+  justBaseCalls?: boolean;
+}): ChromatogramData | void {
+  if (!seqToInsert.length) return;
+
+  if (chromatogramData.baseCalls) {
+    (chromatogramData.baseCalls as unknown[]).splice(
+      caretPosition,
+      0,
+      ...seqToInsert.split("")
+    );
+  }
+  if (justBaseCalls) {
+    //return early if just base calls
+    return chromatogramData;
+  }
+
+  const baseTracesToInsert: unknown[] = [];
+  const qualNumsToInsert: number[] = [];
+
+  for (let index = 0; index < seqToInsert.length; index++) {
+    qualNumsToInsert.push(0);
+    const toPush = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    baseTracesToInsert.push({
+      aTrace: toPush,
+      cTrace: toPush,
+      gTrace: toPush,
+      tTrace: toPush
+    });
+  }
+
+  if (chromatogramData.baseTraces) {
+    (chromatogramData.baseTraces as unknown[]).splice(
+      caretPosition,
+      0,
+      ...baseTracesToInsert
+    );
+  }
+  if (chromatogramData.qualNums) {
+    (chromatogramData.qualNums as unknown[]).splice(
+      caretPosition,
+      0,
+      ...qualNumsToInsert
+    );
+  }
+
+  return chromatogramData;
+}
+
+function trimChromatogram({
+  chromatogramData,
+  range: { start, end },
+  justBaseCalls
+}: {
+  chromatogramData: ChromatogramData;
+  range: { start: number; end: number };
+  justBaseCalls?: boolean;
+}): ChromatogramData {
+  [
+    "baseCalls",
+    ...(justBaseCalls ? [] : ["qualNums", "baseTraces", "basePos"])
+  ].forEach(type => {
+    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.ts

@@ -0,0 +1,61 @@
+// ac.throw([ac.posInt, ac.posInt, ac.bool], arguments);
+import mapAnnotationsToRows, { MappedAnnotation } from "./mapAnnotationsToRows";
+
+import { annotationTypes } from "./annotationTypes";
+
+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
+) {
+  // ac.throw([ac.sequenceData, ac.posInt], arguments);
+  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: RowData[] = [];
+  const rowMap: Record<
+    string,
+    Record<string | number, MappedAnnotation[]>
+  > = {};
+  annotationTypes.forEach(type => {
+    rowMap[type] = mapAnnotationsToRows(
+      (sequenceData[type] as Annotation[]) || [],
+      sequenceLength,
+      bpsPerRow,
+      { splitForwardReverse: type === "primers" }
+    );
+  });
+
+  for (let rowNumber = 0; rowNumber < totalRows; rowNumber++) {
+    const row: RowData = {
+      rowNumber,
+      start: 0,
+      end: 0,
+      sequence: ""
+    };
+    row.rowNumber = rowNumber;
+    row.start = rowNumber * bpsPerRow;
+    row.end =
+      (rowNumber + 1) * bpsPerRow - 1 < sequenceLength
+        ? (rowNumber + 1) * bpsPerRow - 1
+        : sequenceLength - 1;
+    if (row.end < 0) {
+      row.end = 0;
+    }
+    annotationTypes.forEach(type => {
+      row[type] = rowMap[type][rowNumber] || [];
+    });
+    row.sequence = sequenceData.sequence.slice(row.start, row.end + 1);
+
+    rows[rowNumber] = row;
+  }
+  return rows;
+}

package/src/prepareRowData_output1.json

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