@teselagen/ove 0.0.14 → 0.0.16

package/src/updateEditor.js

@@ -0,0 +1,198 @@
+import { set } from "lodash";
+import { tidyUpSequenceData } from "@teselagen/sequence-utils";
+import { annotationTypes } from "@teselagen/sequence-utils";
+
+export default function updateEditor(
+  store,
+  editorName,
+  initialValues = {},
+  extraMeta = {},
+  { convertAnnotationsFromAAIndices } = {}
+) {
+  const {
+    sequenceData,
+    annotationVisibility,
+    annotationsToSupport,
+    findTool,
+    justPassingPartialSeqData
+  } = initialValues;
+  const currentEditor = store.getState().VectorEditor[editorName] || {};
+  const isAlreadyProteinEditor =
+    currentEditor.sequenceData && currentEditor.sequenceData.isProtein;
+  const isAlreadyRnaEditor =
+    currentEditor.sequenceData && currentEditor.sequenceData.isRna;
+  const isAlreadyOligoEditor =
+    currentEditor.sequenceData && currentEditor.sequenceData.isOligo;
+  const reverseSequenceShouldBeUpdate =
+    currentEditor.sequenceData?.isSingleStrandedDNA !==
+    sequenceData?.isSingleStrandedDNA;
+
+  const isAlreadySpecialEditor =
+    isAlreadyProteinEditor ||
+    isAlreadyRnaEditor ||
+    isAlreadyOligoEditor ||
+    reverseSequenceShouldBeUpdate;
+
+  let toSpread = {};
+  let payload;
+  if (justPassingPartialSeqData) {
+    payload = {
+      sequenceData: tidyUpSequenceData(
+        { ...currentEditor.sequenceData, ...sequenceData },
+        {
+          convertAnnotationsFromAAIndices,
+          //if we have sequence data coming in make sure to tidy it up for the user :)
+          annotationsAsObjects: true
+        }
+      )
+    };
+  } else {
+    if (sequenceData) {
+      const isDna =
+        !sequenceData.isOligo && !sequenceData.isRna && !sequenceData.isProtein;
+      if (sequenceData.isProtein && !isAlreadyProteinEditor) {
+        //we're editing a protein but haven't initialized the protein editor yet
+        toSpread = {
+          findTool: {
+            dnaOrAA: "AA",
+            ...findTool //we spread this here to allow the user to override this .. if they must!
+          },
+
+          annotationVisibility: {
+            caret: true,
+            ...annotationVisibility, //we spread this here to allow the user to override this .. if they must!
+            sequence: false,
+            reverseSequence: false,
+            cutsites: false,
+            translations: false,
+            aminoAcidNumbers: false,
+            primaryProteinSequence: true
+          },
+          annotationsToSupport: {
+            features: true,
+            translations: false,
+            primaryProteinSequence: true,
+            parts: true,
+            orfs: false,
+            cutsites: false,
+            primers: false,
+            ...annotationsToSupport
+          }
+        };
+      } else if (sequenceData.isOligo && !isAlreadyOligoEditor) {
+        toSpread = {
+          findTool: {
+            dnaOrAA: "DNA",
+            ...findTool //we spread this here to allow the user to override this .. if they must!
+          },
+          annotationVisibility: {
+            caret: true,
+            ...annotationVisibility, //we spread this here to allow the user to override this .. if they must!
+            sequence: true,
+            cutsites: false,
+            reverseSequence: false,
+            translations: false,
+            aminoAcidNumbers: false,
+            primaryProteinSequence: false
+          },
+          annotationsToSupport: {
+            features: true,
+            translations: true,
+            primaryProteinSequence: false,
+            parts: true,
+            orfs: false,
+            cutsites: true,
+            primers: false,
+            ...annotationsToSupport //we spread this here to allow the user to override this .. if they must!
+          }
+        };
+      } else if (sequenceData.isRna && !isAlreadyRnaEditor) {
+        toSpread = {
+          findTool: {
+            dnaOrAA: "DNA",
+            ...findTool //we spread this here to allow the user to override this .. if they must!
+          },
+          annotationVisibility: {
+            caret: true,
+            ...annotationVisibility, //we spread this here to allow the user to override this .. if they must!
+            sequence: true,
+            cutsites: false,
+            reverseSequence: false,
+            translations: false,
+            aminoAcidNumbers: false,
+            primaryProteinSequence: false
+          },
+          annotationsToSupport: {
+            features: true,
+            translations: true,
+            primaryProteinSequence: false,
+            parts: true,
+            orfs: true,
+            cutsites: true,
+            primers: true,
+            ...annotationsToSupport //we spread this here to allow the user to override this .. if they must!
+          }
+        };
+      } else if (isAlreadySpecialEditor && isDna) {
+        //we're editing dna but haven't initialized the dna editor yet
+        sequenceData.isProtein = false;
+        toSpread = {
+          findTool: {
+            dnaOrAA: "DNA",
+            ...findTool //we spread this here to allow the user to override this .. if they must!
+          },
+          annotationVisibility: {
+            caret: true,
+            ...annotationVisibility, //we spread this here to allow the user to override this .. if they must!
+            sequence: true,
+            reverseSequence: !sequenceData?.isSingleStrandedDNA,
+            translations: false,
+            aminoAcidNumbers: false,
+            primaryProteinSequence: false
+          },
+          annotationsToSupport: {
+            features: true,
+            translations: true,
+            primaryProteinSequence: false,
+            parts: true,
+            orfs: true,
+            cutsites: true,
+            primers: true,
+            ...annotationsToSupport //we spread this here to allow the user to override this .. if they must!
+          }
+        };
+      }
+    }
+    payload = {
+      ...initialValues,
+      ...toSpread,
+      ...(sequenceData && {
+        sequenceData: tidyUpSequenceData(sequenceData, {
+          convertAnnotationsFromAAIndices,
+          //if we have sequence data coming in make sure to tidy it up for the user :)
+          annotationsAsObjects: true
+        })
+      })
+    };
+  }
+  annotationTypes.forEach((t) => {
+    if (Object.keys(sequenceData?.[t] || {}).length > 100) {
+      set(payload, `annotationLabelVisibility.${t}`, false);
+    }
+  });
+  if (sequenceData && sequenceData.size > 20000) {
+    set(payload, "annotationVisibility.translations", false);
+    set(payload, "annotationVisibility.cutsites", false);
+  }
+
+  store.dispatch({
+    type: "VECTOR_EDITOR_UPDATE",
+    payload,
+    meta: {
+      mergeStateDeep: true,
+      editorName,
+      disregardUndo: true,
+      ...extraMeta
+    }
+  });
+}

package/src/utils/PassThrough.js

@@ -0,0 +1,3 @@
+export default function({ children }) {
+  return children;
+}

package/src/utils/addWrappedAddons.js

@@ -0,0 +1,20 @@
+import { flatMap } from "lodash";
+import { normalizePositionByRangeLength } from "@teselagen/range-utils";
+
+export function addWrappedAddons(anns, seqLen) {
+  return flatMap(anns, (ann) => {
+    if (ann.overlapsSelf) {
+      return [
+        ann,
+        {
+          ...ann,
+          start: normalizePositionByRangeLength(ann.end + 1, seqLen),
+          end: normalizePositionByRangeLength(ann.start - 1, seqLen),
+          isWrappedAddon: true,
+          rangeTypeOverride: "middle" //we add this rangeTypeOverride here to get the wrapping piece to draw differently than normal
+        }
+      ];
+    }
+    return [ann];
+  });
+}

package/src/utils/annotationTypes.js

@@ -0,0 +1,37 @@
+export const userDefinedTypes = [
+  "parts",
+  "features",
+  "translations",
+  "primers"
+];
+
+export const userDefinedTypesMap = userDefinedTypes.reduce(function(
+  nextVal,
+  key
+) {
+  nextVal[key] = key;
+  return nextVal;
+  //  looks like this:
+  //{
+  // 	parts: 'parts',
+  // 	features: 'features',
+  // 	translations: 'translations',
+  // 	primers: 'primers',
+  // }
+},
+{});
+
+export const derivedDataTypes = ["cutsites", "orfs"];
+export const derivedDataTypesMap = derivedDataTypes.reduce(function(
+  nextVal,
+  key
+) {
+  nextVal[key] = key;
+  return nextVal;
+},
+{});
+export function getSingular(type) {
+  return type.slice(0, -1);
+}
+
+export const allTypes = [...userDefinedTypes, ...derivedDataTypes];

package/src/utils/arrayUtils.js

@@ -0,0 +1,19 @@
+export function insertItem(array, item, index) {
+  return [...array.slice(0, index), item, ...array.slice(index)];
+}
+
+export function removeItem(array, i) {
+  return array.filter((_, j) => j !== Number(i));
+}
+
+export function getLowerCaseObj(obj = {}) {
+  let key;
+  const keys = Object.keys(obj);
+  let n = keys.length;
+  const newobj = {};
+  while (n--) {
+    key = keys[n];
+    newobj[key.toLowerCase()] = obj[key];
+  }
+  return newobj;
+}

package/src/utils/calculateTickMarkPositionsForGivenRange.js

@@ -0,0 +1,47 @@
+import { normalizePositionByRangeLength as norm } from "@teselagen/range-utils";
+import { getRangeLength } from "@teselagen/range-utils";
+
+export default function calculateTickMarkPositionsForGivenRange({
+  tickSpacing: _tickSpacing = 10,
+  range,
+  sequenceLength,
+  isProtein,
+  increaseOffset
+}) {
+  if (sequenceLength === 0) {
+    return [];
+  }
+  let tickSpacing = _tickSpacing;
+  if (isProtein) {
+    tickSpacing = Math.floor((_tickSpacing / 2) * 3);
+  }
+
+  const rangeLength = getRangeLength(range, sequenceLength);
+
+  let spacer = 0;
+  if (increaseOffset) {
+    spacer = range.start;
+  }
+  const firstTickOffsetFromRangeStart =
+    spacer + tickSpacing - (range.start % tickSpacing);
+
+  const tickMarks = [];
+  if (range.start === 0) tickMarks.push(isProtein ? 2 : 0);
+  let hasCrossedOrigin;
+  for (
+    let tick = firstTickOffsetFromRangeStart - 1;
+    tick < spacer + rangeLength;
+    tick += tickSpacing
+  ) {
+    let normed = norm(tick, sequenceLength);
+    if (!hasCrossedOrigin && normed < tick) {
+      if (!(normed % 10) && normed !== 0) {
+        tick = tick - 1;
+        normed = normed - 1;
+      }
+      if (normed !== 0) hasCrossedOrigin = true;
+    }
+    tickMarks.push(normed);
+  }
+  return tickMarks;
+}

package/src/utils/cleanSequenceData_DEPRECATED/arrayToObjWithIds.js

@@ -0,0 +1,17 @@
+//helper function to make sure any arrays coming in
+
+import shortid from "shortid";
+
+//get converted to objects with unique ids
+export default function arrayToObjWithIds(array) {
+  const newObj = {};
+  array.forEach(function (item) {
+    const newItem = {
+      ...item,
+      id: item.id || shortid()
+    };
+    newObj[newItem.id] = newItem;
+  });
+
+  return newObj;
+}

package/src/utils/combineReducersDontIgnoreKeys.js

@@ -0,0 +1,12 @@
+export default function combineReducersDontIgnoreKeys(reducers) {
+  return function(state = {}, action) {
+    const newState = Object.keys(reducers).reduce((acc, key) => {
+      acc[key] = reducers[key](state[key], action);
+      return acc;
+    }, {});
+    return {
+      ...state,
+      ...newState
+    };
+  };
+}

package/src/utils/commandUtils.js

@@ -0,0 +1,18 @@
+import { genericCommandFactory } from "@teselagen/ui";
+import { noop } from "lodash";
+
+export function oveCommandFactory(instance, commandDefs) {
+  return genericCommandFactory({
+    getArguments(cmdId, [ctxInfo]) {
+      const args = [instance.props];
+      const { store, editorName } = instance.props;
+      if (store && editorName) {
+        args.push(store.getState().VectorEditor[editorName]);
+      }
+      args.push(ctxInfo);
+      return args;
+    },
+    handleReturn: noop,
+    commandDefs
+  });
+}

package/src/utils/editorUtils.js

@@ -0,0 +1,223 @@
+import { getRangeLength, getSequenceWithinRange } from "@teselagen/range-utils";
+import React from "react";
+import { divideBy3 } from "./proteinUtils";
+import {
+  getInsertBetweenVals,
+  calculatePercentGC,
+  bioData,
+  aliasedEnzymesByName
+} from "@teselagen/sequence-utils";
+import { get, sortBy } from "lodash";
+import VeWarning from "../helperComponents/VeWarning";
+import { normalizePositionByRangeLength } from "@teselagen/range-utils";
+import { filter } from "lodash";
+
+export function getSelectionMessage({
+  caretPosition = -1,
+  selectionLayer = { start: -1, end: -1 },
+  customTitle,
+  sequenceLength,
+  sequenceData,
+  showGCContent, //these are only passed in for the status bar
+  GCDecimalDigits, //these are only passed in for the status bar
+  isProtein
+}) {
+  let _selectionLayer = selectionLayer;
+  const isSelecting = selectionLayer.start > -1;
+  if (isSelecting) {
+    _selectionLayer = getSelFromWrappedAddon(selectionLayer, sequenceLength);
+    const length = getRangeLength(_selectionLayer, sequenceLength);
+    const GCContent = (numDecimalDigits = 0) =>
+      calculatePercentGC(
+        getSequenceWithinRange(_selectionLayer, sequenceData.sequence)
+      ).toFixed(numDecimalDigits);
+    const seqLen = divideBy3(length, isProtein);
+    return `${customTitle || "Selecting"} ${seqLen} ${
+      (isProtein ? "AA" : "bp") + (seqLen === 1 ? "" : "s")
+    } from ${divideBy3(_selectionLayer.start, isProtein) + 1} to ${divideBy3(
+      _selectionLayer.end + 1,
+      isProtein
+    )}${
+      showGCContent && !isProtein ? ` (${GCContent(GCDecimalDigits)}% GC)` : ""
+    }`;
+  } else if (caretPosition > -1) {
+    const insertBetween = getInsertBetweenVals(
+      caretPosition,
+      _selectionLayer,
+      sequenceLength
+    );
+    return (
+      `Caret Between ` +
+      (isProtein
+        ? `AAs ${divideBy3(insertBetween[0], true)} and ${divideBy3(
+            insertBetween[1] + 2,
+            true
+          )}`
+        : `Bases ${insertBetween[0]} and ${insertBetween[1]}`)
+    );
+  } else {
+    return "No Selection";
+  }
+}
+
+export function preventDefaultStopPropagation(e) {
+  if (e) {
+    e.stopPropagation();
+    e.preventDefault();
+  }
+}
+
+export function getNodeToRefocus(caretEl) {
+  let nodeToReFocus;
+  if (
+    caretEl &&
+    caretEl.closest &&
+    caretEl.closest(".veVectorInteractionWrapper")
+  ) {
+    nodeToReFocus = caretEl.closest(".veVectorInteractionWrapper");
+  }
+  return nodeToReFocus;
+}
+
+export function getEmptyText({ sequenceData, caretPosition }) {
+  return sequenceData.sequence.length === 0 && caretPosition === -1 ? (
+    <div className="veEmptySeqText">Insert Sequence Here</div>
+  ) : null;
+}
+
+export function tryToRefocusEditor() {
+  const ed = document.querySelector(".veVectorInteractionWrapper");
+  ed && ed.focus();
+}
+export function getCustomEnzymes() {
+  try {
+    const customEnzymes = JSON.parse(
+      window.localStorage.getItem("customEnzymes") || "{}"
+    );
+    return customEnzymes;
+  } catch (error) {
+    return {};
+  }
+}
+export function addCustomEnzyme(newEnz) {
+  const customEnzymes = getCustomEnzymes();
+  window.localStorage.setItem(
+    "customEnzymes",
+    JSON.stringify({
+      ...customEnzymes,
+      [newEnz.name.toLowerCase()]: newEnz
+    })
+  );
+}
+
+export function pareDownAnnotations(annotations, max) {
+  let annotationsToPass = annotations;
+  let paredDown = false;
+  if (Object.keys(annotations).length > max) {
+    paredDown = true;
+    const sortedAnnotations = sortBy(annotations, function (annotation) {
+      return -getRangeLength(annotation);
+    });
+    annotationsToPass = sortedAnnotations
+      .slice(0, max)
+      .reduce(function (obj, item) {
+        obj[item.id] = item;
+        return obj;
+      }, {});
+  }
+  return [annotationsToPass, paredDown];
+}
+export function getParedDownWarning({ nameUpper, maxToShow, isAdjustable }) {
+  return (
+    <VeWarning
+      key={`ve-warning-max${nameUpper}ToDisplay`}
+      data-test={`ve-warning-max${nameUpper}ToDisplay`}
+      tooltip={`Warning: More than ${maxToShow} ${
+        nameUpper === "Cutsites" ? "Cut Sites" : nameUpper
+      }. Only displaying ${maxToShow} ${
+        isAdjustable ? "(Configure this under View > Limits)" : ""
+      } `}
+    />
+  );
+}
+
+export function getClientX(event) {
+  return event.clientX || get(event, "touches[0].clientX");
+}
+export function getClientY(event) {
+  return event.clientY || get(event, "touches[0].clientY");
+}
+
+export function hideAnnByLengthFilter(hideOpts, ann, seqLen) {
+  const featLength = getRangeLength(ann, seqLen);
+  return (
+    hideOpts.enabled && (featLength < hideOpts.min || featLength > hideOpts.max)
+  );
+}
+
+export function getSelFromWrappedAddon(selectionLayer, sequenceLength) {
+  const selToUse = {
+    ...selectionLayer
+  };
+  if (selectionLayer.isWrappedAddon) {
+    const oldEnd = selToUse.end;
+    selToUse.end = normalizePositionByRangeLength(
+      selToUse.start - 1,
+      sequenceLength
+    );
+    selToUse.start = normalizePositionByRangeLength(oldEnd + 1, sequenceLength);
+    delete selToUse.isWrappedAddon;
+  }
+  return selToUse;
+}
+
+export function getAcceptedChars({
+  isOligo,
+  isProtein,
+  isRna,
+  isMixedRnaAndDna
+} = {}) {
+  return isProtein
+    ? bioData.extended_protein_letters.toLowerCase()
+    : isOligo
+    ? bioData.ambiguous_rna_letters.toLowerCase() + "t"
+    : isRna
+    ? bioData.ambiguous_rna_letters.toLowerCase()
+    : isMixedRnaAndDna
+    ? bioData.ambiguous_rna_letters.toLowerCase() +
+      bioData.ambiguous_dna_letters.toLowerCase()
+    : //just plain old dna
+      bioData.ambiguous_dna_letters.toLowerCase();
+}
+export function getStripedPattern({ color }) {
+  return (
+    <pattern
+      id="diagonalHatch"
+      patternUnits="userSpaceOnUse"
+      width="4"
+      height="4"
+    >
+      <path
+        d="M-1,1 l2,-2
+           M0,4 l4,-4
+           M3,5 l2,-2"
+        style={{
+          stroke: color,
+          strokeWidth: 2,
+          fill: "blue",
+          opacity: 0.4
+        }}
+      />
+    </pattern>
+  );
+}
+export const getEnzymeAliases = (enzyme) => {
+  let lowerName = (enzyme.name && enzyme.name.toLowerCase()) || "";
+  if (typeof enzyme === "string") {
+    lowerName = enzyme.toLowerCase();
+  }
+  return filter(
+    (aliasedEnzymesByName[lowerName] || {}).aliases,
+    (n) => n.toLowerCase() !== lowerName //filter out current enzyme
+  );
+};

package/src/utils/getAnnotationClassnames.js

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

package/src/utils/getAnnotationNameAndStartStopString.js

@@ -0,0 +1,61 @@
+import { upperFirst } from "lodash";
+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/src/utils/getVisibleStartEnd.js

@@ -0,0 +1,7 @@
+export function getVisibleStartEnd({ scrollData, width }) {
+  const { percentScrolled, viewportWidth } = scrollData;
+
+  const visibleStart = percentScrolled * (width - viewportWidth);
+  const visibleEnd = visibleStart + viewportWidth;
+  return { visibleEnd, visibleStart };
+}