@teselagen/ove 0.0.14 → 0.0.16

package/src/selectors/filteredPrimersSelector.js

@@ -0,0 +1,27 @@
+import { createSelector } from "reselect";
+import { omitBy } from "lodash";
+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/src/selectors/filteredRestrictionEnzymesSelector.js

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

package/src/selectors/getAdditionalEnzymesSelector.js

@@ -0,0 +1,46 @@
+import { pickBy } from "lodash";
+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/src/selectors/index.js

@@ -0,0 +1,41 @@
+import cutsitesSelector from "./cutsitesSelector";
+import getAdditionalEnzymesSelector from "./getAdditionalEnzymesSelector";
+import translationsSelector from "./translationsSelector";
+import sequenceLengthSelector from "./sequenceLengthSelector";
+import sequenceDataSelector from "./sequenceDataSelector";
+import sequenceSelector from "./sequenceSelector";
+import circularSelector from "./circularSelector";
+import orfsSelector from "./orfsSelector";
+import selectedCutsitesSelector from "./selectedCutsitesSelector";
+import filteredRestrictionEnzymesSelector from "./filteredRestrictionEnzymesSelector";
+import filteredCutsitesSelector from "./filteredCutsitesSelector";
+import searchLayersSelector from "./searchLayersSelector";
+import annotationSearchSelector from "./annotationSearchSelector";
+import restrictionEnzymesSelector from "./restrictionEnzymesSelector";
+import filteredFeaturesSelector from "./filteredFeaturesSelector";
+import filteredPrimersSelector from "./filteredPrimersSelector";
+import cutsiteLabelColorSelector from "./cutsiteLabelColorSelector";
+import filteredPartsSelector from "./filteredPartsSelector";
+import isEnzymeFilterAndSelector from "./isEnzymeFilterAndSelector";
+
+export default {
+  translationsSelector,
+  getAdditionalEnzymesSelector,
+  cutsitesSelector,
+  sequenceDataSelector,
+  sequenceLengthSelector,
+  selectedCutsitesSelector,
+  orfsSelector,
+  circularSelector,
+  annotationSearchSelector,
+  searchLayersSelector,
+  filteredCutsitesSelector,
+  filteredRestrictionEnzymesSelector,
+  filteredPrimersSelector,
+  filteredFeaturesSelector,
+  filteredPartsSelector,
+  isEnzymeFilterAndSelector,
+  restrictionEnzymesSelector,
+  sequenceSelector,
+  cutsiteLabelColorSelector
+};

package/src/selectors/isEnzymeFilterAndSelector.js

@@ -0,0 +1 @@
+export default (state) => state.restrictionEnzymes.isEnzymeFilterAnd;

package/src/selectors/minimumOrfSizeSelector.js

@@ -0,0 +1,2 @@
+const minimumOrfSizeSelector = state => state.minimumOrfSize;
+export default minimumOrfSizeSelector;

package/src/selectors/orfsSelector.js

@@ -0,0 +1,15 @@
+import circularSelector from "./circularSelector";
+import sequenceSelector from "./sequenceSelector";
+import minimumOrfSizeSelector from "./minimumOrfSizeSelector";
+import { findOrfsInPlasmid } from "@teselagen/sequence-utils";
+import { createSelector } from "reselect";
+
+export default createSelector(
+  sequenceSelector,
+  circularSelector,
+  minimumOrfSizeSelector,
+  (state) => state.useAdditionalOrfStartCodons,
+  findOrfsInPlasmid
+);
+
+//tiny

package/src/selectors/partsSelector.js

@@ -0,0 +1,8 @@
+import { createSelector } from "reselect";
+import sequenceDataSelector from "./sequenceDataSelector";
+
+function partsRawSelector(sequenceData) {
+  return sequenceData.parts;
+}
+
+export default createSelector(sequenceDataSelector, partsRawSelector);

package/src/selectors/primersSelector.js

@@ -0,0 +1,8 @@
+import { createSelector } from "reselect";
+import sequenceDataSelector from "./sequenceDataSelector";
+
+function primersRawSelector(sequenceData) {
+  return sequenceData.primers;
+}
+
+export default createSelector(sequenceDataSelector, primersRawSelector);

package/src/selectors/restrictionEnzymesSelector.js

@@ -0,0 +1,34 @@
+import { forEach } from "lodash";
+import { createSelector } from "reselect";
+import {
+  defaultEnzymesByName,
+  aliasedEnzymesByName
+} from "@teselagen/sequence-utils";
+
+export default createSelector(
+  () => defaultEnzymesByName,
+  (state, additionalEnzymes) => {
+    return additionalEnzymes;
+  },
+  () => localStorage.getItem("enzymeGroups"), //it should recompute if the enzyme groups change in localstorage
+  (defaultEnzymesByName, additionalEnzymes) => {
+    const enzymesFromGroups = {};
+    forEach(window.getExistingEnzymeGroups(), (group) => {
+      forEach(group, (enzymeName) => {
+        const enzyme = { ...aliasedEnzymesByName, ...additionalEnzymes }[
+          enzymeName.toLowerCase()
+        ];
+        if (!enzyme) {
+          console.warn("ruh roh, no enzyme found for: ", enzymeName);
+        } else {
+          enzymesFromGroups[enzymeName.toLowerCase()] = enzyme;
+        }
+      });
+    });
+    return {
+      ...defaultEnzymesByName,
+      ...additionalEnzymes,
+      ...enzymesFromGroups
+    };
+  }
+);

package/src/selectors/searchLayersSelector.js

@@ -0,0 +1,71 @@
+import { findSequenceMatches } from "@teselagen/sequence-utils";
+import sequenceSelector from "./sequenceSelector";
+import { createSelector } from "reselect";
+import circularSelector from "./circularSelector";
+
+function searchLayersSelector(
+  sequence,
+  isCircular,
+  isOpen,
+  searchString,
+  ambiguousOrLiteral,
+  dnaOrAA,
+  isProtein,
+  proteinSequence
+) {
+  if (!searchString || !isOpen) {
+    return [];
+  }
+  if (isProtein) {
+    const searchingDna = dnaOrAA === "DNA";
+    const matches = findSequenceMatches(
+      searchingDna ? sequence : proteinSequence,
+      searchString,
+      {
+        isCircular: false,
+        isProteinSequence: true,
+        isAmbiguous: ambiguousOrLiteral === "AMBIGUOUS",
+        // isProteinSearch: dnaOrAA !== "DNA",
+        searchReverseStrand: false
+      }
+    ).sort(({ start }, { start: start2 }) => {
+      return start - start2;
+    });
+    return searchingDna
+      ? matches
+      : matches.map(({ start, end, ...rest }) => ({
+          ...rest,
+          isSearchLayer: true,
+          start: start * 3,
+          end: end * 3 + 2
+        }));
+  }
+  const matches = findSequenceMatches(sequence, searchString, {
+    isCircular,
+    isAmbiguous: ambiguousOrLiteral === "AMBIGUOUS",
+    isProteinSearch: dnaOrAA !== "DNA",
+    searchReverseStrand: true
+  }).sort(({ start }, { start: start2 }) => {
+    return start - start2;
+  });
+  return matches.map((match) => ({
+    ...match,
+    forward: !match.bottomStrand,
+    className:
+      "veSearchLayer " +
+      (match.bottomStrand ? " veSearchLayerBottomStrand" : ""),
+    isSearchLayer: true
+  }));
+}
+
+export default createSelector(
+  sequenceSelector,
+  circularSelector,
+  (state) => state.findTool && state.findTool.isOpen,
+  (state) => state.findTool && state.findTool.searchText,
+  (state) => state.findTool && state.findTool.ambiguousOrLiteral,
+  (state) => state.findTool && state.findTool.dnaOrAA,
+  (state) => state.sequenceData.isProtein,
+  (state) => state.sequenceData.proteinSequence,
+  searchLayersSelector
+);

package/src/selectors/selectedAnnotationsSelector.js

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

package/src/selectors/selectedCutsitesSelector.js

@@ -0,0 +1,21 @@
+import { createSelector } from "reselect";
+import selectedAnnotationsSelector from "./selectedAnnotationsSelector";
+
+export default createSelector(
+  selectedAnnotationsSelector,
+  function (selectedAnnotations) {
+    const { idStack, idMap } = selectedAnnotations;
+    const cutsiteIdMap = {};
+    const cutsiteIdStack = idStack.filter(function (id) {
+      if (idMap[id].annotationType === "cutsite") {
+        cutsiteIdMap[id] = idMap[id];
+        return true;
+      }
+      return false;
+    });
+    return {
+      idStack: cutsiteIdStack,
+      idMap: cutsiteIdMap
+    };
+  }
+);

package/src/selectors/sequenceDataSelector.js

@@ -0,0 +1,2 @@
+const sequenceDataSelector = state => state.sequenceData;
+export default sequenceDataSelector;

package/src/selectors/sequenceLengthSelector.js

@@ -0,0 +1,5 @@
+import sequenceSelector from "./sequenceSelector";
+
+export default function(state) {
+  return sequenceSelector(state).length;
+}

package/src/selectors/sequenceSelector.js

@@ -0,0 +1,4 @@
+import sequenceDataSelector from "./sequenceDataSelector";
+export default function(state) {
+  return sequenceDataSelector(state).sequence;
+}

package/src/selectors/tagsToBoldSelector.js

@@ -0,0 +1,2 @@
+const tagsToBoldSelector = (state) => state.selectedPartTags.parts;
+export default tagsToBoldSelector;

package/src/selectors/translationSearchMatchesSelector.js

@@ -0,0 +1,14 @@
+import { createSelector } from "reselect";
+import searchLayersSelector from "./searchLayersSelector";
+
+export default createSelector(
+  searchLayersSelector,
+  state => state.findTool && state.findTool.dnaOrAA,
+  state => state.findTool && state.findTool.highlightAll,
+  state => state.findTool && state.findTool.matchNumber,
+  (searchLayers, dnaOrAA, highlightAll, matchNumber) => {
+    if (dnaOrAA === "DNA") return [];
+    if (!highlightAll) return [searchLayers[matchNumber]];
+    return searchLayers;
+  }
+);

package/src/selectors/translationsRawSelector.js

@@ -0,0 +1,8 @@
+import { createSelector } from "reselect";
+import sequenceDataSelector from "./sequenceDataSelector";
+
+function translationsRawSelector(sequenceData) {
+  return sequenceData.translations;
+}
+
+export default createSelector(sequenceDataSelector, translationsRawSelector);

package/src/selectors/translationsSelector.js

@@ -0,0 +1,137 @@
+import { reduce } from "lodash";
+import uuid from "shortid";
+import sequenceSelector from "./sequenceSelector";
+import orfsSelector from "./orfsSelector";
+import { createSelector } from "reselect";
+
+import { getAminoAcidDataForEachBaseOfDna } from "@teselagen/sequence-utils";
+import each from "lodash/each";
+import translationsRawSelector from "./translationsRawSelector";
+import translationSearchMatchesSelector from "./translationSearchMatchesSelector";
+import { normalizePositionByRangeLength } from "@teselagen/range-utils";
+import cdsFeaturesSelector from "./cdsFeaturesSelector";
+import circularSelector from "./circularSelector";
+
+function translationsSelector(
+  isCircular,
+  translationSearchMatches,
+  sequence,
+  orfs,
+  showOrfTranslations,
+  showOrfs,
+  cdsFeatures,
+  showCdsFeatureTranslations,
+  showFeatures,
+  translations,
+  frameTranslations
+) {
+  const translationsToPass = {
+    ...translationSearchMatches.reduce((acc, match) => {
+      if (!match) return acc;
+      const id = match.id || uuid();
+      acc[id] = {
+        ...match,
+        id,
+        translationType: "AA Search Match",
+        isOrf: true, //pass isOrf = true here in order to not have it show up in the properties window
+        forward: !match.bottomStrand
+      };
+      return acc;
+    }, {}),
+    ...reduce(
+      translations,
+      (acc, translation) => {
+        if (!translation.isOrf) {
+          acc[translation.id] = {
+            ...translation,
+            translationType: "User Created"
+          };
+        }
+        return acc;
+      },
+      {}
+    ),
+    ...(showOrfTranslations && showOrfs
+      ? reduce(
+          orfs,
+          (acc, orf) => {
+            acc[orf.id] = { ...orf, translationType: "ORF" };
+            return acc;
+          },
+          {}
+        )
+      : {}),
+    ...(showCdsFeatureTranslations &&
+      showFeatures &&
+      reduce(
+        cdsFeatures,
+        (acc, cdsFeature) => {
+          acc[cdsFeature.id] = {
+            ...cdsFeature,
+            translationType: "CDS Feature"
+          };
+          return acc;
+        },
+        {}
+      )),
+    ...reduce(
+      frameTranslations,
+      (acc, isActive, frameName) => {
+        const frameOffset = Number(frameName);
+        if (isActive) {
+          const id = uuid();
+          acc[id] = {
+            id,
+            start:
+              isCircular || frameOffset > 0
+                ? normalizePositionByRangeLength(
+                    0 + frameOffset + (frameOffset > 0 ? -1 : 1),
+                    sequence.length
+                  )
+                : 0,
+            end:
+              isCircular || frameOffset < 0
+                ? normalizePositionByRangeLength(
+                    sequence.length -
+                      1 +
+                      frameOffset +
+                      (frameOffset > 0 ? -1 : 1),
+                    sequence.length
+                  )
+                : sequence.length - 1,
+            translationType: "Frame",
+            forward: frameOffset > 0,
+            isOrf: true //pass isOrf = true here in order to not have it show up in the properties window
+          };
+        }
+        return acc;
+      },
+      {}
+    )
+  };
+  each(translationsToPass, function (translation) {
+    translation.aminoAcids = getAminoAcidDataForEachBaseOfDna(
+      sequence,
+      translation.forward,
+      translation
+    );
+  });
+  return translationsToPass;
+}
+
+export default createSelector(
+  circularSelector,
+  translationSearchMatchesSelector,
+  sequenceSelector,
+  orfsSelector,
+  (state) => state.annotationVisibility.orfTranslations,
+  (state) => state.annotationVisibility.orfs,
+  cdsFeaturesSelector,
+  (state) => state.annotationVisibility.cdsFeatureTranslations,
+  (state) => state.annotationVisibility.features,
+  translationsRawSelector,
+  (state) => state.frameTranslations,
+  (state) => state.sequenceData.isProtein,
+  (state) => state.sequenceData.proteinSequence,
+  translationsSelector
+);

package/src/style.css

@@ -0,0 +1,82 @@
+.ve-monospace-font {
+  font-family: "Ubuntu Mono", "Lucida Console", Monaco, monospace;
+  font-size: 12px;
+}
+.rowViewTextContainer text {
+  user-select: none;
+}
+.translationLayer text {
+  user-select: none;
+}
+.ve-sequence-reverse {
+  fill: #b0b0b0;
+}
+
+.veCircularView .ve-monospace-font {
+  font-family: "Lucida Console", Monaco, monospace;
+  font-size: 14px;
+}
+
+.vespacer {
+  height: 15px;
+}
+
+.clickable {
+  cursor: pointer;
+}
+
+.openVeContextMenu .bp3-key {
+  box-shadow: none;
+  margin: 0px !important;
+  padding: 0px !important;
+  height: 11px;
+  line-height: 7px;
+  background: none;
+}
+
+.openVeContextMenu .bp3-icon-standard {
+  font-size: 10px;
+  height: 10px;
+}
+
+.veCutsiteLabel {
+  font-style: italic;
+  user-select: none;
+}
+
+.veCutsiteLabel:hover {
+  font-weight: bold;
+}
+
+/* .disable-hover .veRowItem {
+  pointer-events: none !important;
+} */
+
+.veWhiteBackground {
+  background: white;
+}
+
+.tg-min-width-dialog {
+  min-width: 300px;
+}
+
+/* this is necessary to allow the editor and its portals to sit at the top of the z-index stack for jbei */
+
+.ove-portal {
+  z-index: 100000;
+}
+body.tg-no-scroll-body {
+  overflow-x: hidden;
+  overflow-y: hidden;
+}
+
+.veToolbar {
+  padding-top: 3px;
+}
+.veToolbar-outer {
+  padding-bottom: 1px;
+  background: #ebf1f5;
+}
+.bp3-dark .veToolbar-outer {
+  background: #202b33;
+}