@teselagen/ove 0.7.26 → 0.7.28

package/filteredPartsSelector.js

@@ -0,0 +1,57 @@
+import { createSelector } from "reselect";
+import partsSelector from "./partsSelector";
+import tagsToBoldSelector from "./tagsToBoldSelector";
+import { some, keyBy, omitBy } from "lodash-es";
+import { map } from "lodash-es";
+import sequenceLengthSelector from "./sequenceLengthSelector";
+import { hideAnnByLengthFilter } from "../utils/editorUtils";
+import { addWrappedAddons } from "../utils/addWrappedAddons";
+
+function filteredPartsSelector(
+  parts,
+  seqLen,
+  partIndividualToHide,
+  tagsToBold,
+  lengthsToHide
+) {
+  if (tagsToBold) {
+    const keyedTagsToBold = keyBy(tagsToBold, "value");
+
+    return map(parts || {}, p => {
+      if (p.tags) {
+        if (
+          some(p.tags, tagId => {
+            return keyedTagsToBold[tagId];
+          })
+        ) {
+          return {
+            ...p,
+            className: "partWithSelectedTag",
+            labelClassName: "partWithSelectedTag",
+            highPriorityLabel: true
+          };
+        } else {
+          return p;
+        }
+      }
+    });
+  }
+
+  const toRet = map(
+    omitBy(parts, ann => {
+      const hideIndividually = partIndividualToHide[ann.id];
+      return (
+        hideAnnByLengthFilter(lengthsToHide, ann, seqLen) || hideIndividually
+      );
+    })
+  );
+  return addWrappedAddons(toRet, seqLen);
+}
+export default createSelector(
+  partsSelector,
+  sequenceLengthSelector,
+  state => state.annotationVisibility.partIndividualToHide,
+  tagsToBoldSelector,
+  state => state.partLengthsToHide,
+  filteredPartsSelector
+);

package/filteredPrimersSelector.js

@@ -0,0 +1,27 @@
+import { createSelector } from "reselect";
+import { omitBy } from "lodash-es";
+import primersSelector from "./primersSelector";
+import sequenceLengthSelector from "./sequenceLengthSelector";
+import { hideAnnByLengthFilter } from "../utils/editorUtils";
+
+function filteredPrimersSelector(
+  primers,
+  seqLen,
+  primerIndividualToHide,
+  lengthsToHide
+) {
+  return omitBy(primers, ann => {
+    const hideIndividually = primerIndividualToHide[ann.id];
+    return (
+      hideAnnByLengthFilter(lengthsToHide, ann, seqLen) || hideIndividually
+    );
+  });
+}
+
+export default createSelector(
+  primersSelector,
+  sequenceLengthSelector,
+  state => state.annotationVisibility.primerIndividualToHide,
+  state => state.primerLengthsToHide,
+  filteredPrimersSelector
+);

package/filteredRestrictionEnzymesSelector.js

@@ -0,0 +1 @@
+export default state => state.restrictionEnzymes.filteredRestrictionEnzymes;

package/findTool.js

@@ -0,0 +1,79 @@
+import createAction from "./utils/createMetaAction";
+import createMergedDefaultStateReducer from "./utils/createMergedDefaultStateReducer";
+import { noop } from "lodash-es";
+
+// ------------------------------------
+// Actions
+// ------------------------------------
+export const toggleFindTool = createAction("TOGGLE_FIND_TOOL", noop); //NOTE!!:: second argument sanitizes actions so no payload is passed!
+export const toggleHighlightAll = createAction("toggleHighlightAll", noop); //NOTE!!:: second argument sanitizes actions so no payload is passed!
+export const toggleIsInline = createAction("toggleIsInline", noop); //NOTE!!:: second argument sanitizes actions so no payload is passed!
+export const updateSearchText = createAction("updateSearchText");
+export const updateAmbiguousOrLiteral = createAction(
+  "updateAmbiguousOrLiteral"
+);
+export const updateDnaOrAA = createAction("updateDnaOrAA");
+export const updateMatchNumber = createAction("updateMatchNumber");
+
+// ------------------------------------
+// Reducer
+// ------------------------------------
+export default createMergedDefaultStateReducer(
+  {
+    [toggleFindTool]: state => {
+      return {
+        ...state,
+        isOpen: !state.isOpen
+      };
+    },
+    [toggleHighlightAll]: state => {
+      return {
+        ...state,
+        highlightAll: !state.highlightAll
+      };
+    },
+    [toggleIsInline]: state => {
+      localStorage.setItem("veFindBarIsExpanded", state.isInline);
+      return {
+        ...state,
+        isInline: !state.isInline
+      };
+    },
+    [updateAmbiguousOrLiteral]: (state, payload) => {
+      return {
+        ...state,
+        matchNumber: 0,
+        ambiguousOrLiteral: payload
+      };
+    },
+    [updateDnaOrAA]: (state, payload) => {
+      return {
+        ...state,
+        matchNumber: 0,
+        dnaOrAA: payload
+      };
+    },
+    [updateSearchText]: (state, payload) => {
+      return {
+        ...state,
+        matchNumber: 0,
+        searchText: payload
+      };
+    },
+    [updateMatchNumber]: (state, payload) => {
+      return {
+        ...state,
+        matchNumber: payload
+      };
+    }
+  },
+  {
+    isOpen: false,
+    isInline: !localStorage.getItem("veFindBarIsExpanded"),
+    searchText: "",
+    dnaOrAA: "DNA",
+    ambiguousOrLiteral: "LITERAL",
+    highlightAll: false,
+    matchNumber: 0
+  }
+);

package/findToolConstants.js

@@ -0,0 +1 @@
+export const MAX_MATCHES_DISPLAYED = 1000;

package/frameTranslations.js

@@ -0,0 +1,52 @@
+//./caretPosition.js
+import { createReducer } from "redux-act";
+import createAction from "./utils/createMetaAction";
+
+// ------------------------------------
+// Actions
+// ------------------------------------
+export const frameTranslationToggle = createAction("FRAME_TRANSLATION_TOGGLE");
+export const frameTranslationToggleOn = createAction(
+  "FRAME_TRANSLATION_TOGGLE_ON"
+);
+export const frameTranslationToggleOff = createAction(
+  "FRAME_TRANSLATION_TOGGLE_OFF"
+);
+
+// ------------------------------------
+// Reducer
+// ------------------------------------
+export default createReducer(
+  {
+    [frameTranslationToggle]: (state, payload) => {
+      return {
+        ...state,
+        [payload]: !state[payload]
+      };
+    },
+    [frameTranslationToggleOn]: (state, payload) => {
+      return {
+        ...state,
+        [payload]: true
+      };
+    },
+    [frameTranslationToggleOff]: (state, payload) => {
+      return {
+        ...state,
+        [payload]: false
+      };
+    }
+  },
+  {
+    1: false,
+    2: false,
+    3: false,
+    "-1": false,
+    "-2": false,
+    "-3": false
+  }
+);
+
+export function getMinimumOrfSize(state) {
+  return state;
+}

package/getAdditionalEnzymesSelector.js

@@ -0,0 +1,46 @@
+import { pickBy } from "lodash-es";
+import { createSelector } from "reselect";
+import { getLowerCaseObj } from "../utils/arrayUtils";
+import { getCustomEnzymes } from "../utils/editorUtils";
+
+export default createSelector(
+  () => window.localStorage.getItem("customEnzymes"),
+  (state, additionalEnzymes) => additionalEnzymes,
+  (customEnzymesString, additionalEnzymes) => {
+    return getLowerCaseObj(
+      pickBy(
+        {
+          ...additionalEnzymes,
+          ...getCustomEnzymes(customEnzymesString)
+        },
+        (val, key) => {
+          if (!val) {
+            console.error(
+              "43ti3523: Error: Missing enzyme data for key: ",
+              key,
+              "Ignoring this enzyme"
+            );
+            return false;
+          }
+
+          // eslint-disable-next-line no-unused-vars
+          for (const prop of [
+            "forwardRegex",
+            "reverseRegex",
+            "topSnipOffset",
+            "bottomSnipOffset",
+            "site"
+          ]) {
+            if (val[prop] === undefined || val[prop] === null) {
+              console.error(
+                `23483g93h Error: Missing property ${prop} for enzyme ${key}. Ignoring this enzyme`
+              );
+              return false;
+            }
+          }
+          return true;
+        }
+      )
+    );
+  }
+);

package/getAngleForPositionMidpoint.js

@@ -0,0 +1,3 @@
+export default function getAngleForPositionMidpoint(position, maxLength) {
+  return maxLength === 0 ? 0 : ((position + 0.5) / maxLength) * Math.PI * 2;
+}

package/getAnnotationClassnames.js

@@ -0,0 +1,12 @@
+import classnames from "classnames";
+import { upperFirst } from "lodash-es";
+
+export default function getAnnotationClassnames(
+  { overlapsSelf },
+  { viewName, type }
+) {
+  const Type = upperFirst(type);
+  return classnames(`ve${Type}`, `ve${viewName}${Type}`, {
+    overlapsSelf
+  });
+}

package/getAnnotationNameAndStartStopString.js

@@ -0,0 +1,61 @@
+import { upperFirst } from "lodash-es";
+import { getSingular } from "./annotationTypes";
+
+export default function getAnnotationNameAndStartStopString(
+  {
+    name,
+    start,
+    end,
+    type,
+    message,
+    annotationTypePlural,
+    overlapsSelf,
+    isWrappedAddon
+  },
+  { startText, isProtein, readOnly } = {}
+) {
+  const typeToUse = (() => {
+    if (annotationTypePlural) {
+      const singularKey = getSingular(annotationTypePlural);
+      if (singularKey === "cutsite") {
+        return (
+          "Cut site" + (annotationTypePlural === "features" ? ` (${type})` : "")
+        );
+      }
+      if (singularKey === "orf") {
+        return (
+          "ORF" + (annotationTypePlural === "features" ? ` (${type})` : "")
+        );
+      }
+      return (
+        upperFirst(getSingular(annotationTypePlural)) +
+        (annotationTypePlural === "features" ? ` (${type})` : "")
+      );
+    }
+    return "";
+  })();
+
+  if (isWrappedAddon) {
+    const oldEnd = end;
+    end = start - 1;
+    start = oldEnd + 1;
+  }
+  return `${startText ? startText : ""} ${typeToUse ? typeToUse + " -" : ""} ${
+    name ? name : ""
+  } - Start: ${isProtein ? (start + 3) / 3 : start + 1} End: ${
+    isProtein ? (end + 1) / 3 : end + 1
+  } ${overlapsSelf ? "(Overlaps Self) " : ""}${message ? "\n" + message : ""} ${
+    readOnly
+      ? ""
+      : annotationTypePlural === "cutsites"
+        ? `
+
+ click --> top cut position
+ alt/option+click --> bottom cut position
+ cmd/ctrl+click --> recognition range`
+        : `
+
+alt/option+click --> jump row view to start/end
+double click --> edit`
+  }`;
+}

package/getBpsPerRow.js

@@ -0,0 +1,19 @@
+import {
+  defaultCharWidth,
+  defaultContainerWidth,
+  defaultMarginWidth
+} from "../constants/rowviewContants";
+
+export default function getBpsPerRow({
+  charWidth = defaultCharWidth,
+  width = defaultContainerWidth,
+  dimensions: { width: width2 } = {},
+  marginWidth = defaultMarginWidth,
+  sequenceData
+}) {
+  const toRet = Math.floor(
+    ((width2 || width) - marginWidth) /
+      (sequenceData.isProtein ? charWidth * 3 : charWidth)
+  );
+  return sequenceData.isProtein ? toRet * 3 : toRet;
+}

package/getCutsiteLabelHeights.js

@@ -0,0 +1,56 @@
+//tnr: not actually used yet. I don't think it is necessary
+// for the cutsite label heights to be perfect
+
+import getXStartAndWidthOfRowAnnotation from "./getXStartAndWidthOfRowAnnotation";
+import IntervalTree from "node-interval-tree";
+import getYOffset from "../CircularView/getYOffset";
+import forEach from "lodash/forEach";
+
+export default function getCutsiteLabelHeights({
+  bpsPerRow,
+  charWidth,
+  annotationRanges,
+  annotationHeight,
+  spaceBetweenAnnotations,
+  textWidth
+}) {
+  const rowLength = bpsPerRow * charWidth;
+  let counter = 0;
+  let maxAnnotationYOffset = 0;
+  const rowCenter = rowLength / 2;
+  const iTree = new IntervalTree(rowCenter);
+  forEach(annotationRanges, function (annotationRange) {
+    counter++;
+    if (counter > 50) return;
+    let annotation = annotationRange.annotation;
+    if (!annotation) {
+      annotation = annotationRange;
+    }
+    const labelLength = annotation.restrictionEnzyme.name.length * textWidth;
+    let { xStart } = getXStartAndWidthOfRowAnnotation(
+      annotationRange,
+      bpsPerRow,
+      charWidth
+    );
+    let xEnd = xStart + labelLength;
+
+    if (xEnd > rowLength) {
+      xStart = xStart - (xEnd - rowLength);
+      xEnd = rowLength;
+    }
+    const yOffset = getYOffset(iTree, xStart, xEnd);
+    iTree.insert(xStart, xEnd, {
+      ...annotationRange,
+      yOffset
+    });
+
+    if (yOffset > maxAnnotationYOffset) {
+      maxAnnotationYOffset = yOffset;
+    }
+    const height = yOffset * (annotationHeight + spaceBetweenAnnotations);
+    annotation.height = height;
+  });
+  const containerHeight =
+    (maxAnnotationYOffset + 1) * (annotationHeight + spaceBetweenAnnotations);
+  return containerHeight;
+}

package/getGapMap.js

@@ -0,0 +1,12 @@
+export function getGapMap(sequence) {
+  const gapMap = [0]; //a map of position to how many gaps come before that position [0,0,0,5,5,5,5,17,17,17, ]
+  sequence.split("").forEach(char => {
+    if (char === "-") {
+      gapMap[Math.max(0, gapMap.length - 1)] =
+        (gapMap[Math.max(0, gapMap.length - 1)] || 0) + 1;
+    } else {
+      gapMap.push(gapMap[gapMap.length - 1] || 0);
+    }
+  });
+  return gapMap;
+}

package/getGaps.js

@@ -0,0 +1,27 @@
+import { getGapMap } from "./getGapMap";
+
+/**
+ * this function is used to calculate the number of spaces that come before or inside a range
+ */
+export let getGaps = () => ({
+  gapsBefore: 0,
+  gapsInside: 0
+});
+getGaps = (rangeOrCaretPosition, sequence) => {
+  const gapMap = getGapMap(sequence);
+  if (typeof rangeOrCaretPosition !== "object") {
+    return {
+      gapsBefore: gapMap[Math.min(rangeOrCaretPosition, gapMap.length - 1)]
+    };
+  }
+  //otherwise it is a range!
+  const { start, end } = rangeOrCaretPosition;
+  const toReturn = {
+    gapsBefore: gapMap[start],
+    gapsInside:
+      gapMap[Math.min(end, gapMap.length - 1)] -
+      gapMap[Math.min(start, gapMap.length - 1)]
+  };
+
+  return toReturn;
+};

package/getInternalLabel.js

@@ -0,0 +1,40 @@
+import Color from "color";
+import React from "react";
+
+export function getInternalLabel({
+  ellipsizedName,
+  id,
+  annotationType,
+  revTransform,
+  angleAdjust,
+  isPart,
+  colorToUse,
+  textPath,
+  locationNumber
+}) {
+  if (!ellipsizedName) return null;
+  const pathId = `${annotationType}${id}${locationNumber ?? ""}`;
+  return (
+    <>
+      <path id={pathId} fill="none" d={textPath.print()}></path>
+      <text
+        className="veLabelText veCircularViewInternalLabelText ve-monospace-font"
+        transform={
+          (revTransform || "") + (angleAdjust ? ` rotate(${angleAdjust})` : "")
+        }
+        fill={
+          isPart ? "#ac68cc" : Color(colorToUse).isDark() ? "white" : "black"
+        }
+        dy={-3}
+      >
+        <textPath
+          textAnchor="middle"
+          startOffset="50%"
+          xlinkHref={`#${pathId}`}
+        >
+          {ellipsizedName}
+        </textPath>
+      </text>
+    </>
+  );
+}

package/getOveHotkeyDefs.js

@@ -0,0 +1,12 @@
+import getCommands from "./index";
+import { getCommandHotkeys } from "@teselagen/ui";
+
+export default function getOveHotkeyDefs({ store, editorName }) {
+  const commands = getCommands({
+    props: {
+      store,
+      editorName
+    }
+  });
+  return getCommandHotkeys(commands);
+}

package/getPairwiseOverviewLinearViewOptions.js

@@ -0,0 +1,38 @@
+export function getPairwiseOverviewLinearViewOptions({ isTemplate }) {
+  if (!isTemplate) {
+    return {
+      annotationVisibilityOverrides: {
+        features: false,
+        translations: false,
+        parts: false,
+        orfs: false,
+        orfTranslations: false,
+        cdsFeatureTranslations: false,
+        axis: false,
+        cutsites: false,
+        primers: false,
+        chromatogram: false,
+        sequence: false,
+        dnaColors: false,
+        reverseSequence: false,
+        axisNumbers: false
+      }
+    };
+  } else {
+    return {
+      // annotationVisibilityOverrides: {
+      //   features: false,
+      //   yellowAxis: false,
+      //   translations: false,
+      //   parts: false,
+      //   orfs: false,
+      //   orfTranslations: false,
+      //   axis: true,
+      //   cutsites: false,
+      //   primers: false,
+      //   reverseSequence: false,
+      //   axisNumbers: false
+      // }
+    };
+  }
+}

package/getRangeAnglesSpecial.js

@@ -0,0 +1,12 @@
+import { getRangeAngles } from "@teselagen/range-utils";
+export default function getRangeAnglesSpecial() {
+  const { endAngle, totalAngle, ...rest } = getRangeAngles.apply(
+    this,
+    arguments
+  );
+  return {
+    endAngle: endAngle - 0.00001, //we subtract a tiny amount because an angle of 2PI will cause nothing to be drawn!
+    totalAngle: totalAngle - 0.00001, //we subtract a tiny amount because we don't want the range comparisons to treat the same angle as overlapping
+    ...rest
+  };
+}

package/getStructuredBases.js

@@ -0,0 +1,97 @@
+import { clone } from "lodash-es";
+import { getRangeLength, getSequenceWithinRange } from "@teselagen/range-utils";
+import { getComplementSequenceString } from "@teselagen/sequence-utils";
+import { bioData } from "@teselagen/sequence-utils";
+const { ambiguous_dna_values } = bioData;
+export function getStructuredBases({
+  annotationRange,
+  forward,
+  bases = "",
+  start,
+  end,
+  fullSequence,
+  primerBindsOn,
+  sequenceLength
+}) {
+  const annLen = getRangeLength({ start, end }, sequenceLength);
+  let basesToUse = bases;
+  if (bases.length < annLen) {
+    if (forward && primerBindsOn === "3prime") {
+      const toAddLen = annLen - bases.length;
+      for (let index = 0; index < toAddLen; index++) {
+        basesToUse = "&" + basesToUse;
+      }
+    } else if (!forward && primerBindsOn === "5prime") {
+      const toAddLen = annLen - bases.length;
+      for (let index = 0; index < toAddLen; index++) {
+        basesToUse = basesToUse + "&";
+      }
+    }
+  }
+  const aRange = {
+    //tnr: this probably needs to be changed in case annotation wraps origin
+    start: annotationRange.start - start,
+    end: annotationRange.end - start
+  };
+  const r = {
+    aRange,
+    basesNoInserts: basesToUse,
+    inserts: []
+  };
+
+  const baseLen = basesToUse.length;
+  const diffLen = baseLen - annLen;
+  if (diffLen > 0) {
+    r.basesNoInserts = basesToUse.slice(
+      primerBindsOn === "5prime" ? 0 : diffLen,
+      primerBindsOn === "5prime" ? annLen : baseLen
+    );
+    const insertBases = basesToUse.slice(
+      primerBindsOn === "5prime" ? annLen : 0,
+      primerBindsOn === "5prime" ? baseLen : diffLen
+    );
+
+    r.inserts = [
+      {
+        bases: insertBases,
+        index: primerBindsOn === "5prime" ? annLen : 0
+      }
+    ];
+  }
+  const basesForRange = getSequenceWithinRange(
+    aRange,
+    forward ? r.basesNoInserts : r.basesNoInserts.split("").reverse().join("")
+  );
+  r.basesNoInsertsWithMetaData = basesForRange.split("").map((b, i) => {
+    const indexOfBase = i + annotationRange.start;
+    let seqForBase = (fullSequence && fullSequence[indexOfBase]) || "";
+    if (!forward) {
+      seqForBase = getComplementSequenceString(seqForBase);
+    }
+    const isMatch = seqForBase.toLowerCase() === b.toLowerCase();
+    const isAmbiguousMatch =
+      !isMatch &&
+      ambiguous_dna_values[b.toUpperCase()]?.length > 1 &&
+      ambiguous_dna_values[b.toUpperCase()]?.includes(seqForBase.toUpperCase());
+    return {
+      b,
+      isMatch,
+      isAmbiguousMatch
+    };
+  });
+  r.allBasesWithMetaData = clone(r.basesNoInsertsWithMetaData);
+  if (!forward) {
+    r.allBasesWithMetaData = r.allBasesWithMetaData.reverse();
+  }
+  r.inserts
+    .sort((a, b) => a.index - b.index)
+    .forEach(({ bases, index }) => {
+      r.allBasesWithMetaData.splice(
+        index,
+        0,
+        ...bases.split("").map(b => ({ b, isMatch: false }))
+      );
+    });
+
+  return r;
+}