@teselagen/ove 0.7.26 → 0.7.28

package/relaxLabelAngles.js

@@ -0,0 +1,157 @@
+import { cloneDeep } from "lodash-es";
+
+export default relaxLabelAngles;
+
+function normalizeAngle(angle) {
+  if (angle > Math.PI * 2) {
+    return angle - Math.PI * 2;
+  } else if (angle < 0) {
+    return angle + Math.PI * 2;
+  } else {
+    return angle;
+  }
+}
+
+//this pure function allows the labels to spread out around the circle
+//and groups overlapping labels together if necessary
+function relaxLabelAngles(_labelPoints, spacing, maxradius) {
+  const maxLabelsPerQuadrant = Math.floor(maxradius / spacing) + 4;
+  let labels = cloneDeep(_labelPoints);
+  if (labels.length > maxLabelsPerQuadrant * 4) {
+    //group overlapping labels together
+    labels = combineLabels(labels, maxLabelsPerQuadrant * 4);
+  }
+  // labels = labels.sort(sortLabelsByAngle)
+
+  // Sort labels into four quadrants of the screen.
+  const totalLength = Math.PI * 2;
+
+  let rightTopLabels = [];
+  let rightBottomLabels = [];
+  let leftTopLabels = [];
+  let leftBottomLabels = [];
+
+  let label;
+  for (let i = 0; i < labels.length; i++) {
+    label = labels[i];
+    label.angle = normalizeAngle(label.angle);
+    const labelCenter = label.angle;
+    if (labelCenter <= totalLength / 4) {
+      rightTopLabels.push(label);
+    } else if (
+      labelCenter > totalLength / 4 &&
+      labelCenter <= totalLength / 2
+    ) {
+      rightBottomLabels.push(label);
+    } else if (
+      labelCenter > totalLength / 2 &&
+      labelCenter <= (3 * totalLength) / 4
+    ) {
+      leftBottomLabels.push(label);
+    } else {
+      leftTopLabels.push(label);
+    }
+  }
+
+  function repositionAndGroupLabels(labels /* logtrue */) {
+    const extraSpaces = Math.max(maxLabelsPerQuadrant - labels.length, 0);
+    let lastLabelYPosition = 0 - spacing / 2; // spacing to count label height
+    let lastlabel;
+    return labels
+      .map(function (label, idx) {
+        if (Math.abs(lastLabelYPosition) > maxradius + 80) {
+          lastlabel.labelAndSublabels.push(label);
+          lastlabel.labelIds[label.id] = true;
+          return false;
+        }
+        lastlabel = label;
+        if (label.y < lastLabelYPosition) {
+          const naturalSlot = Math.floor(Math.abs(label.y / spacing));
+          if (naturalSlot > extraSpaces) {
+            if (idx < naturalSlot && extraSpaces > 0) {
+              lastLabelYPosition = label.y;
+            }
+            label.y = lastLabelYPosition;
+          }
+          let x = Math.sqrt(Math.pow(maxradius, 2) - Math.pow(label.y, 2));
+          if (!x) x = 0;
+          label.x = label.x > 0 ? x : -x;
+          lastLabelYPosition = label.y - spacing;
+        } else {
+          label.y = lastLabelYPosition;
+          lastLabelYPosition = label.y - spacing;
+        }
+        return label;
+      })
+      .filter(function (l) {
+        return !!l;
+      });
+  }
+
+  // Scale Right Top Labels
+  let labelsToReturn = [];
+  rightTopLabels = rightTopLabels.sort(sortLabelsByAngleReverse);
+  labelsToReturn = labelsToReturn.concat(
+    repositionAndGroupLabels(rightTopLabels, true)
+  );
+
+  // Scale Right Bottom Labels
+  rightBottomLabels = rightBottomLabels.sort(sortLabelsByAngle);
+  labelsToReturn = labelsToReturn.concat(
+    flipLabelYs(repositionAndGroupLabels(flipLabelYs(rightBottomLabels)))
+  );
+
+  // Scale Left Bottom Labels
+  leftBottomLabels = leftBottomLabels.sort(sortLabelsByAngleReverse);
+  labelsToReturn = labelsToReturn.concat(
+    flipLabelYs(repositionAndGroupLabels(flipLabelYs(leftBottomLabels)))
+  );
+
+  // Scale Left Top Labels
+  leftTopLabels = leftTopLabels.sort(sortLabelsByAngle);
+  labelsToReturn = labelsToReturn.concat(
+    repositionAndGroupLabels(leftTopLabels)
+  );
+
+  return labelsToReturn;
+
+  function flipLabelYs(labels) {
+    return labels.map(function (label) {
+      label.y = -label.y;
+      return label;
+    });
+  }
+}
+
+// function sortLabelsByHeight(a, b) {
+//   return b.innerPoint.y - a.innerPoint.y
+// }
+
+function sortLabelsByAngle(a, b) {
+  return a.angle - b.angle;
+}
+function sortLabelsByAngleReverse(b, a) {
+  return a.angle - b.angle;
+}
+
+//function that groups labels that fall within the same angle together
+function combineLabels(labels, numberOfBuckets) {
+  const buckets = {};
+  Object.keys(labels).forEach(function (key) {
+    const label = labels[key];
+
+    const bucket = Math.floor(
+      (label.annotationCenterAngle / 6.29) * numberOfBuckets
+    );
+    if (!buckets[bucket]) {
+      buckets[bucket] = label;
+    } else {
+      buckets[bucket].labelAndSublabels.push(label);
+      buckets[bucket].labelIds[label.id] = true;
+    }
+  });
+  const combinedLabels = Object.keys(buckets).map(function (key) {
+    return buckets[key];
+  });
+  return combinedLabels;
+}

package/relaxLabels_DEPRECATED.js

@@ -0,0 +1,105 @@
+/* eslint-disable */
+// import intervalTree2 from "node-interval-tree";
+// var xRanges = new intervalTree2(0)
+// var yRanges = new intervalTree2(0)
+// iTree.search(start, end)
+// featureITree.add(startAngle, expandedEndAngle, undefined, {...annotationCopy})
+
+let alpha = 1.5; //the larger the alpha, the fewer loops through relax necessary, but too large and things are spaced unevenly
+let spacing = 12;
+let relaxCounter = 0;
+export default function relaxLabels(labelPoints) {
+  let mutableLabelPoints = labelPoints.map(function (point) {
+    return {
+      ...point
+    };
+  });
+  function spreadPointsOutOnCircle(labels) {}
+  function relax() {
+    let again = false;
+    relaxCounter++;
+    mutableLabelPoints.forEach(function (point1, index1) {
+      // var xOverlaps = xRanges.search(point1.x, point1.x + point1.width)
+      // var yOverlaps = yRanges.search(point1.y, point1.y + point1.height)
+      // xOverlaps
+      // xRanges.add(point1.x, point1.x + point1.width, undefined, point1)
+      // yRanges.add(point1.y, point1.y + point1.height, undefined, point1)
+
+      mutableLabelPoints.forEach(function (point2, index2) {
+        // a & b are the same element and don't collide.
+        if (index1 === index2) return;
+
+        // a & b are on opposite sides of the chart and
+        // don't collide
+        if (
+          (point1.x > 0 && point2.x <= 0) ||
+          (point1.x < 0 && point2.x >= 0)
+        ) {
+          return;
+        }
+        // Now let's calculate the distance between
+        // these elements.
+        let deltaY = point1.y - point2.y;
+
+        // Our spacing is greater than our specified spacing,
+        // so they don't collide.
+        if (Math.abs(deltaY) > spacing) return;
+
+        // If the labels collide, we'll push each
+        // of the two labels up and down a little bit.
+        let weight1 = point1.y > 0 ? 0.5 : -0.5;
+        let weight2 = point2.y > 0 ? 0.5 : -0.5;
+        again = true;
+        let sign = deltaY > 0 ? 1 : -1;
+        let adjust = sign * alpha;
+        point1.y += adjust + weight1;
+        point2.y -= adjust + weight2;
+
+        // point1.x += -weight1
+        // point2.x -= -weight2
+      });
+    });
+    // Adjust our line leaders here
+    // so that they follow the labels.
+    if (again && relaxCounter < 1) {
+      relax();
+    }
+  }
+  relax();
+
+  //group colliding labels
+  let stableLabels = [];
+  mutableLabelPoints.forEach(function (point1) {
+    let collision = false;
+    stableLabels.some(function (point2) {
+      // a & b are on opposite sides of the chart and
+      // don't collide
+      if ((point1.x > 0 && point2.x <= 0) || (point1.x < 0 && point2.x >= 0)) {
+        return;
+      }
+      // Now let's calculate the distance between
+      // these elements.
+      let deltaY = point1.y - point2.y;
+
+      // Our spacing is greater than our specified spacing,
+      // so they don't collide.
+      if (Math.abs(deltaY) > spacing) return;
+      // If the labels collide, we'll push each
+      collision = true;
+      point2.labels.push(point1);
+      return true; //stop the loop early
+    });
+    if (!collision) {
+      stableLabels.push({
+        ...point1,
+        labels: [point1]
+      });
+    }
+  });
+  stableLabels = stableLabels.sort(sortLabels);
+  return stableLabels;
+}
+
+function sortLabels(a, b) {
+  return b.y - a.y;
+}

package/replacementLayers.js

@@ -0,0 +1,36 @@
+//./selectionLayer.js
+import { createReducer } from "redux-act";
+import createAction from "./utils/createMetaAction";
+import omit from "lodash/omit";
+
+// ------------------------------------
+// Actions
+// ------------------------------------
+export const replacementLayerClear = createAction("replacementLayerClear");
+export const replacementLayerUpdate = createAction("REPLACEMENT_LAYER_UPDATE");
+export const replacementLayerDelete = createAction("REPLACEMENT_LAYER_DELETE");
+
+// ------------------------------------
+// Reducer
+// ------------------------------------
+export default createReducer(
+  {
+    [replacementLayerClear]: () => {
+      return {};
+    },
+    [replacementLayerUpdate]: (state, payload) => {
+      return {
+        ...state,
+        [payload.id]: {
+          color: "darkolivegreen",
+          id: payload.id,
+          ...payload.range
+        }
+      };
+    },
+    [replacementLayerDelete]: (state, payload) => {
+      return omit(state, payload.id);
+    }
+  },
+  {}
+);

package/restrictionEnzymes.js

@@ -0,0 +1,52 @@
+import { combineReducers } from "redux";
+import { createReducer } from "redux-act";
+import createAction from "./utils/createMetaAction";
+import specialCutsiteFilterOptions from "../constants/specialCutsiteFilterOptions";
+// ------------------------------------
+// Actions
+// ------------------------------------
+export const filteredRestrictionEnzymesUpdate = createAction(
+  "FILTERED_RESTRICTION_ENZYMES_UPDATE"
+);
+export const isEnzymeFilterAndUpdate = createAction("IS_ENZYME_FILTER_AND");
+export const filteredRestrictionEnzymesReset = createAction(
+  "FILTERED_RESTRICTION_ENZYMES_RESET"
+);
+export const filteredRestrictionEnzymesAdd = createAction(
+  "FILTERED_RESTRICTION_ENZYMES_ADD"
+);
+// ------------------------------------
+// Reducer
+// ------------------------------------
+const defaultInitialState = [specialCutsiteFilterOptions.single];
+// let initialState = defaultInitialState;
+// const localDefault = window.localStorage.getItem("tgInitialCutsiteFilter");
+
+// if (localDefault) {
+//   try {
+//     initialState = JSON.parse(localDefault);
+//     if (!Array.isArray(initialState)) throw new Error("Must be an array");
+//   } catch (e) {
+//     initialState = defaultInitialState;
+//   }
+// }
+
+export default combineReducers({
+  //filteredRestrictionEnzymes refer to the enzymes actively included in the react-select filter component
+  isEnzymeFilterAnd: createReducer(
+    {
+      [isEnzymeFilterAndUpdate]: (state, payload) => payload
+    },
+    false
+  ),
+  filteredRestrictionEnzymes: createReducer(
+    {
+      [filteredRestrictionEnzymesReset]: () => defaultInitialState,
+      [filteredRestrictionEnzymesUpdate]: (state, payload) => payload,
+      [filteredRestrictionEnzymesAdd]: function (state, payload) {
+        return [...state, payload];
+      }
+    },
+    defaultInitialState
+  )
+});

package/restrictionEnzymesSelector.js

@@ -0,0 +1,34 @@
+import { forEach } from "lodash-es";
+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/rowviewContants.js

@@ -0,0 +1,3 @@
+export const defaultCharWidth = 9;
+export const defaultContainerWidth = 400;
+export const defaultMarginWidth = 50;

package/ruler.css

@@ -0,0 +1,89 @@
+/* .managerListLadder {
+  height: 265px;
+  overflow: visible;
+  border: 1px solid #E0E0E0;
+  padding: 0 !important;
+  position: fixed;
+  width: 225px;
+}
+
+.left {
+  border-color: black;
+  position: absolute;
+  height: 5px;
+  width: 80%;
+}
+
+.right {
+  border-color: black;
+  position: absolute;
+  height: 5px;
+  width: 80%;
+}
+
+.tooltip {
+  position: absolute;
+  height: 0;
+}
+
+.tooltip .tooltiptext {
+  visibility: hidden;
+  position: absolute;
+  width: auto;
+  background-color: black;
+  color: white;
+  text-align: left;
+  padding: 5px;
+  font-size: 7pt;
+  bottom: 5px;
+  white-space: nowrap;
+  border-radius: 6px;
+}
+
+.tooltip .tooltiptext::after {
+  content: " ";
+  /* i don't know what this content attribute does, but it works... */
+/* position: absolute;
+  top: 100%;
+  left: 50%;
+  margin-left: -5px;
+  border-width: 5px;
+  border-style: solid;
+  border-color: black transparent transparent transparent;
+}
+
+.tooltip:hover .tooltiptext {
+  visibility: visible;
+}
+
+.rightLabel {
+  margin-right: 2%;
+  margin-left: 60%;
+  position: relative;
+}
+
+.leftLabel {
+  margin-left: 2%;
+  margin-right: 60%;
+  position: relative;
+}
+
+.block {
+  height: 265px;
+  max-height: none;
+  padding-bottom: 40px;
+  padding-top: 10px;
+  overflow: scroll;
+}
+
+.fragmentsNumLabel {
+  text-align: left;
+  padding: 0 5px;
+  color: #333333;
+  height: 30px;
+  width: 100%;
+}
+ 
+
+
+*/

package/saveTool.js

@@ -0,0 +1,44 @@
+import React from "react";
+import { Icon } from "@blueprintjs/core";
+import ToolbarItem from "./ToolbarItem";
+import { connectToEditor, handleSave } from "../withEditorProps";
+import { withHandlers } from "recompose";
+import { compose } from "redux";
+
+export default compose(
+  connectToEditor(
+    ({ readOnly, sequenceData = {}, lastSavedId = "134%!@#%!@#%!@%" }) => {
+      return {
+        readOnly: readOnly,
+        sequenceData: sequenceData,
+        hasBeenSaved:
+          sequenceData.stateTrackingId === "initialLoadId" ||
+          sequenceData.stateTrackingId === lastSavedId
+      };
+    }
+  ),
+  withHandlers({ handleSave })
+)(({
+  toolbarItemProps,
+  alwaysAllowSave,
+  handleSave,
+  readOnly,
+  hasBeenSaved,
+  onSave
+}) => {
+  return (
+    <ToolbarItem
+      {...{
+        Icon: <Icon data-test="saveTool" icon="floppy-disk" />,
+        onIconClick: handleSave,
+        disabled: alwaysAllowSave ? false : !onSave || hasBeenSaved || readOnly,
+        tooltip: (
+          <span>
+            Save <span style={{ fontSize: 10 }}>(Cmd/Ctrl+S)</span>
+          </span>
+        ),
+        ...toolbarItemProps
+      }}
+    />
+  );
+});

package/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/selectedAnnotations.js

@@ -0,0 +1,89 @@
+import { showContextMenu } from "@teselagen/ui";
+import without from "lodash/without";
+import { createReducer } from "redux-act";
+import createAction from "./utils/createMetaAction";
+
+// ------------------------------------
+// Actions
+// ------------------------------------
+export const annotationSelect = createAction("VE_ANNOTATION_SELECT");
+export const updateSelectedAnnotation = createAction(
+  "VE_ANNOTATION_UPDATE_SELECTED"
+);
+export const annotationDeselect = createAction("VE_ANNOTATION_DESELECT");
+export const annotationDeselectAll = createAction("VE_ANNOTATION_DESELECT_ALL");
+
+export function replacementLayerRightClicked({ event, annotation }, meta) {
+  event.preventDefault();
+  event.stopPropagation();
+  return function (dispatch /* getState */) {
+    const items = [
+      {
+        text: "Remove Edit",
+        onClick: function () {
+          dispatch({
+            type: "REPLACEMENT_LAYER_DELETE",
+            meta,
+            payload: { ...annotation }
+          });
+        }
+      }
+    ];
+
+    showContextMenu(items, undefined, event);
+  };
+}
+
+// ------------------------------------
+// Reducer
+// ------------------------------------
+const startingState = {
+  idMap: {},
+  idStack: []
+};
+export default createReducer(
+  {
+    [annotationSelect]: (state, payload) => {
+      if (!payload.id) throw new Error("Annotation must have an id!");
+      const newState = {
+        idMap: {
+          ...state.idMap,
+          [payload.id]: payload
+        },
+        idStack: [...state.idStack, payload.id]
+      };
+      return newState;
+    },
+    [annotationDeselect]: (state, payload) => {
+      const id = payload.id || payload;
+      const idMap = { ...state.idMap };
+      delete idMap[id];
+      const idStack = without(state.idStack, id);
+      return {
+        idMap,
+        idStack
+      };
+    },
+    [updateSelectedAnnotation]: (state, payload) => {
+      const id = payload.id;
+      const idMap = { ...state.idMap };
+      if (!idMap[id]) {
+        return state;
+      }
+      return {
+        idMap: {
+          ...idMap,
+          [id]: {
+            ...idMap[id],
+            ...payload
+          }
+        },
+        idStack: state.idStack
+      };
+    },
+    [annotationDeselectAll]: () => {
+      return startingState;
+    }
+  },
+  startingState
+);

package/selectedAnnotationsSelector.js

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