@teselagen/ove 0.7.26 → 0.7.28

package/index.js

@@ -0,0 +1,71 @@
+import { getReverseComplementSequenceAndAnnotations } from "@teselagen/sequence-utils";
+
+export default function addDashesForMatchStartAndEndForTracks(alignmentTracks) {
+  return alignmentTracks.map((track, i) => {
+    // .filter by the user-specified mismatch overrides (initially [])
+    return {
+      ...track,
+      ...addDashesForMatchStartAndEnd(
+        track,
+        alignmentTracks[0], //send in the ref/template seq every time
+        i === 0
+      )
+    };
+  });
+}
+
+function addDashesForMatchStartAndEnd(
+  { alignmentData, sequenceData: _sequenceData },
+  template,
+  isTemplate
+) {
+  let sequenceData = _sequenceData;
+  const {
+    sequenceData: sequenceDataTemplate,
+    alignmentData: alignmentDataTemplate
+  } = template;
+  let { matchStart = 0, matchEnd = 0, strand } = alignmentData;
+  if (strand === -1) {
+    sequenceData = getReverseComplementSequenceAndAnnotations(sequenceData);
+    const oldMatchEnd = matchEnd;
+    const oldMatchStart = matchStart;
+    matchStart = sequenceData.sequence.length - oldMatchStart;
+    matchEnd = sequenceData.sequence.length - oldMatchEnd;
+  }
+  const { matchStart: matchStartTemplate = 0, matchEnd: matchEndTemplate = 0 } =
+    alignmentDataTemplate;
+  let newAlignmentData;
+  if (isTemplate) {
+    newAlignmentData = {
+      ...alignmentData,
+      sequence:
+        sequenceDataTemplate.sequence.slice(0, matchStartTemplate) +
+        alignmentData.sequence +
+        sequenceDataTemplate.sequence.slice(matchEndTemplate + 1)
+    };
+  } else {
+    newAlignmentData = {
+      ...alignmentData,
+      sequence:
+        sequenceData.sequence.slice(0, matchStart) +
+        alignmentData.sequence +
+        sequenceData.sequence.slice(matchEnd + 1)
+    };
+    newAlignmentData = {
+      ...alignmentData,
+      sequence:
+        "-".repeat(Math.max(matchStartTemplate - matchStart, 0)) +
+        newAlignmentData.sequence +
+        "-".repeat(
+          Math.max(
+            sequenceDataTemplate.sequence.slice(matchEndTemplate + 1).length -
+              (sequenceData.sequence.length - matchEnd) +
+              1,
+            0
+          )
+        )
+    };
+  }
+
+  return { alignmentData: newAlignmentData, sequenceData: sequenceData };
+}

package/inlineFindTool.js

@@ -0,0 +1,38 @@
+import React from "react";
+import { Icon } from "@blueprintjs/core";
+import FindBar from "../FindBar";
+import ToolbarItem from "./ToolbarItem";
+import { connectToEditor } from "../withEditorProps";
+
+export default connectToEditor(({ findTool = {} }) => {
+  return {
+    isOpen: findTool.isOpen
+  };
+})(({ toolbarItemProps, editorName, toggleFindTool, isOpen }) => {
+  return (
+    <ToolbarItem
+      {...{
+        Icon: !isOpen ? (
+          <div>
+            <Icon data-test="ve-find-tool-toggle" icon="search" />
+            <Icon icon="caret-right" />
+          </div>
+        ) : (
+          <FindBar editorName={editorName} />
+        ),
+        renderIconAbove: isOpen,
+        onIconClick: toggleFindTool,
+        tooltip: isOpen ? (
+          <span>
+            Hide Find Tool <span style={{ fontSize: 10 }}>(Cmd/Ctrl+F)</span>
+          </span>
+        ) : (
+          <span>
+            Show Find Tool <span style={{ fontSize: 10 }}>(Cmd/Ctrl+F)</span>
+          </span>
+        ),
+        ...toolbarItemProps
+      }}
+    />
+  );
+});

package/isElementInViewport.js

@@ -0,0 +1,29 @@
+export function isElWithinAnotherEl(el, container) {
+  if (el.left > container.right) return false;
+  if (el.right < container.left) return false;
+  return true;
+}
+const buffer = 13;
+export function isElWithinAnotherElWithDiff(el, container) {
+  const elWidth = el.right - el.left;
+  const containerWidth = container.right - container.left;
+  const space = containerWidth - elWidth;
+  if (el.right > container.right) {
+    let diff = container.right - el.right - space / 2;
+    if (el.left + diff < container.left + buffer) {
+      //too far to the left -- aka diff too negative
+      diff += container.left + buffer - el.left - diff;
+    }
+    return [false, diff];
+  }
+
+  if (el.left < container.left) {
+    let diff = container.left - el.left + space / 2;
+    if (el.right + diff + buffer > container.right) {
+      //too far to the right -- aka diff too big
+      diff -= el.right + diff + buffer - container.right;
+    }
+    return [false, diff];
+  }
+  return [true];
+}

package/isEnzymeFilterAndSelector.js

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

package/isTargetWithinEl.js

@@ -0,0 +1,6 @@
+// function Ident({ children }) {
+//   return children;
+// }
+export function isTargetWithinEl(event, selector) {
+  return event.target.closest(selector);
+}

package/labelLineIntensity.js

@@ -0,0 +1,25 @@
+import { createReducer } from "redux-act";
+
+import createAction from "./utils/createMetaAction";
+
+// ------------------------------------
+// Actions
+// ------------------------------------
+export const changeLabelLineIntensity = createAction(
+  "changeLabelLineIntensity"
+);
+
+const newVal = window.localStorage.getItem("labelLineIntensity");
+
+// ------------------------------------
+// Reducer
+// ------------------------------------
+export default createReducer(
+  {
+    [changeLabelLineIntensity]: (state, payload) => {
+      localStorage.setItem("labelLineIntensity", payload);
+      return payload;
+    }
+  },
+  newVal ? parseFloat(newVal) : 0.1 //  0.1 (low) || 0.4 (med) || 0.7 (high) || 1.0 (full)
+);

package/labelSize.js

@@ -0,0 +1,23 @@
+import { createReducer } from "redux-act";
+
+import createAction from "./utils/createMetaAction";
+
+// ------------------------------------
+// Actions
+// ------------------------------------
+export const changeLabelSize = createAction("changeLabelSize");
+
+const newVal = window.localStorage.getItem("labelSize");
+
+// ------------------------------------
+// Reducer
+// ------------------------------------
+export default createReducer(
+  {
+    [changeLabelSize]: (state, payload) => {
+      localStorage.setItem("labelSize", payload);
+      return payload;
+    }
+  },
+  newVal ? parseInt(newVal) : 8 //  8 is 100% label size
+);

package/ladderDefaults.js

@@ -0,0 +1,25 @@
+export const ladderDefaults = [
+  {
+    value: "geneRuler1KB",
+    label: "GeneRuler 1kb + DNA 75-20,000 bp",
+    markings: [
+      20000, 10000, 7000, 5000, 4000, 3000, 2000, 1500, 1000, 700, 500, 400,
+      300, 200, 75
+    ]
+  },
+  {
+    value: "geneRuler100BP",
+    label: "GeneRuler 100bp + DNA 100-3000 bp",
+    markings: [
+      3000, 2000, 1500, 1200, 1000, 900, 800, 700, 600, 500, 400, 300, 200, 100
+    ]
+  },
+  {
+    value: "invitrogen1KbPlus",
+    label: "Invitrogen 1kb + DNA 100-15,000 bp",
+    markings: [
+      15000, 10000, 8000, 7000, 6000, 5000, 4000, 3000, 2000, 1500, 1000, 850,
+      650, 500, 400, 300, 200, 100
+    ]
+  }
+];

package/lastSavedId.js

@@ -0,0 +1,20 @@
+//./caretPosition.js
+import { createReducer } from "redux-act";
+import createAction from "./utils/createMetaAction";
+
+// ------------------------------------
+// Actions
+// ------------------------------------
+export const lastSavedIdUpdate = createAction("lastSavedIdUpdate"); //NOTE!!:: second argument sanitizes actions so no payload is passed
+
+// ------------------------------------
+// Reducer
+// ------------------------------------
+export default createReducer(
+  {
+    [lastSavedIdUpdate]: (state, payload) => {
+      return payload;
+    }
+  },
+  null
+);

package/lineageLines.js

@@ -0,0 +1,11 @@
+import { createReducer } from "redux-act";
+
+// ------------------------------------
+// Actions
+// ------------------------------------
+// export const caretPositionClear = createAction('caretPositionClear')
+
+// ------------------------------------
+// Reducer
+// ------------------------------------
+export default createReducer({}, []);

package/makeStore.js

@@ -0,0 +1,34 @@
+//optionally connect to the redux store
+import { createStore, combineReducers, applyMiddleware, compose } from "redux";
+import VectorEditor, { vectorEditorMiddleware } from "../redux";
+import thunk from "redux-thunk";
+import { reducer as form } from "redux-form";
+
+const makeStore = () => {
+  const composeEnhancer =
+    (window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ &&
+      window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__({
+        name: "createVectorEditor",
+        latency: 1000,
+        // serialize: {
+        //   replacer: (key, value) => {
+        //   }
+        // },
+        actionsDenylist: ["HOVEREDANNOTATIONUPDATE", "HOVEREDANNOTATIONCLEAR"]
+      })) ||
+    compose;
+
+  const store = createStore(
+    combineReducers({
+      form,
+      VectorEditor: VectorEditor()
+    }),
+    undefined,
+    composeEnhancer(
+      applyMiddleware(thunk, vectorEditorMiddleware) //your store should be redux-thunk connected for the VectorEditor component to work
+    )
+  );
+  return store;
+};
+
+export default makeStore;

package/massageTickSpacing.js

@@ -0,0 +1,19 @@
+import { some } from "lodash-es";
+
+export function massageTickSpacing(spacing) {
+  let toRet = spacing;
+  if (spacing < 15) {
+    return 10;
+  }
+  some(
+    [20, 50, 100, 500, 1000, 2000, 5000, 10000, 50000, 100000, 1000000],
+    val => {
+      if (spacing < val) {
+        toRet = val;
+        return true;
+      }
+    }
+  );
+
+  return toRet;
+}

package/materiallyAvailable.js

@@ -0,0 +1,19 @@
+import { createReducer } from "redux-act";
+import createAction from "../utils/createMetaAction";
+
+// ------------------------------------
+// Actions
+// ------------------------------------
+export const updateAvailability = createAction("updateAvailability");
+
+// ------------------------------------
+// Reducer
+// ------------------------------------
+export default createReducer(
+  {
+    [updateAvailability]: (state, payload) => {
+      return payload;
+    }
+  },
+  true
+);

package/middleware.js

@@ -0,0 +1,112 @@
+//vectorEditorMiddleware
+//used to add undo/redo abilities to OVE
+
+// To Batch actions together use this api:
+// deleteFeature([id1, id2], {
+//   batchUndoStart: true
+// });
+// upsertFeature(
+// {
+//   ...feat1,
+//   id: uuid(),
+//   start: start - 1,
+//   end: end - 1,
+//   name
+// },
+// {
+//   batchUndoEnd: true
+// }
+// );
+
+export default store => next => action => {
+  if (action.meta && action.meta.disregardUndo) {
+    return next(action);
+  }
+  const disregardUndo = true;
+  if (action.type === "VE_UNDO" || action.type === "VE_REDO") {
+    const { VectorEditor } = store.getState();
+    const editorName = action.meta.editorName;
+    const editorState = VectorEditor[editorName];
+    const stack =
+      editorState.sequenceDataHistory[
+        action.type === "VE_UNDO" ? "past" : "future"
+      ] || [];
+    const stateToUse = stack[stack.length - 1];
+    store.dispatch({
+      type: action.type === "VE_UNDO" ? "VE_UNDO_META" : "VE_REDO_META",
+      payload: {
+        sequenceData: editorState.sequenceData,
+        selectionLayer: editorState.selectionLayer,
+        caretPosition: editorState.caretPosition
+      },
+      meta: { editorName, disregardUndo }
+    });
+    store.dispatch({
+      type: "SEQUENCE_DATA_UPDATE",
+      payload: stateToUse.sequenceData,
+      meta: { editorName, disregardUndo }
+    });
+    if (stateToUse.caretPosition > -1) {
+      store.dispatch({
+        type: "CARET_POSITION_UPDATE",
+        payload: stateToUse.caretPosition,
+        meta: { editorName, disregardUndo }
+      });
+    } else {
+      store.dispatch({
+        type: "SELECTION_LAYER_UPDATE",
+        payload: { ...stateToUse.selectionLayer, forceUpdate: Math.random() },
+        meta: { editorName, disregardUndo }
+      });
+    }
+    store.dispatch({
+      type: "VE_SEQUENCE_CHANGED", //used for external autosave functionality
+      payload: {
+        sequenceData: stateToUse.sequenceData,
+        editorName
+      },
+      meta: { editorName, disregardUndo: true }
+    });
+    return next(action);
+  } else {
+    //pass batchUndoStart, batchUndoMiddle and batchUndoEnd to group actions together
+    const { batchUndoEnd, batchUndoStart, batchUndoMiddle } = action.meta || {};
+    //get editor state(s)
+    const OldVectorEditor = store.getState().VectorEditor;
+    const result = next(action);
+    const NewVectorEditor = store.getState().VectorEditor;
+    Object.keys(NewVectorEditor).forEach(editorName => {
+      const newEditorState = NewVectorEditor[editorName];
+      const oldEditorState = OldVectorEditor[editorName];
+      if (
+        oldEditorState &&
+        oldEditorState.sequenceData &&
+        oldEditorState.sequenceData !== newEditorState.sequenceData
+      ) {
+        const { sequenceData, selectionLayer, caretPosition } = oldEditorState;
+        !batchUndoEnd &&
+          !batchUndoMiddle &&
+          store.dispatch({
+            type: "ADD_TO_UNDO_STACK",
+            payload: {
+              selectionLayer,
+              sequenceData,
+              caretPosition
+            },
+            meta: { editorName, disregardUndo }
+          });
+        !batchUndoStart &&
+          !batchUndoMiddle &&
+          store.dispatch({
+            type: "VE_SEQUENCE_CHANGED", //used for external autosave functionality
+            payload: {
+              sequenceData: newEditorState.sequenceData,
+              editorName
+            },
+            meta: { editorName, disregardUndo: true }
+          });
+      }
+    });
+    return result;
+  }
+};

package/minimumOrfSize.js

@@ -0,0 +1,24 @@
+//./caretPosition.js
+import { createReducer } from "redux-act";
+import createAction from "./utils/createMetaAction";
+
+// ------------------------------------
+// Actions
+// ------------------------------------
+export const minimumOrfSizeUpdate = createAction("minimumOrfSizeUpdate");
+
+// ------------------------------------
+// Reducer
+// ------------------------------------
+export default createReducer(
+  {
+    [minimumOrfSizeUpdate]: (state, payload) => {
+      return payload;
+    }
+  },
+  300
+);
+
+export function getMinimumOrfSize(state) {
+  return state;
+}

package/minimumOrfSizeSelector.js

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

package/modalActions.js

@@ -0,0 +1,3 @@
+// ------------------------------------
+// Actions
+// ------------------------------------

package/moveCaret.js

@@ -0,0 +1,58 @@
+const handleMoves = {
+  moveCaretLeftOne: function ({ isProtein, selectionLayer, shiftHeld }) {
+    if (selectionLayer.start > -1 && !shiftHeld) {
+      return 0;
+    }
+    return isProtein ? -3 : -1;
+  },
+  moveCaretRightOne: function ({ isProtein, selectionLayer, shiftHeld }) {
+    if (selectionLayer.start > -1 && !shiftHeld) {
+      return 0;
+    }
+    return isProtein ? 3 : 1;
+  },
+  moveCaretUpARow: function ({ bpsPerRow }) {
+    return -bpsPerRow;
+  },
+  moveCaretDownARow: function ({ bpsPerRow }) {
+    return bpsPerRow;
+  },
+  moveCaretToEndOfRow: function ({ bpsPerRow, caretPosition }) {
+    return bpsPerRow - (caretPosition % bpsPerRow);
+  },
+  moveCaretToStartOfRow: function ({ bpsPerRow, caretPosition }) {
+    let moveBy = -caretPosition % bpsPerRow;
+    if (moveBy === 0) {
+      moveBy = -bpsPerRow;
+    }
+    return moveBy;
+  },
+  moveCaretToStartOfSequence: function ({ caretPosition }) {
+    return -caretPosition;
+  },
+  moveCaretToEndOfSequence: function ({ caretPosition, sequenceLength }) {
+    return sequenceLength - caretPosition;
+  }
+};
+
+function moveCaret({
+  sequenceLength,
+  bpsPerRow,
+  caretPosition,
+  selectionLayer,
+  shiftHeld,
+  isProtein,
+  type
+}) {
+  const moveBy = handleMoves[type]({
+    shiftHeld,
+    sequenceLength,
+    isProtein,
+    bpsPerRow,
+    caretPosition,
+    selectionLayer
+  });
+  return moveBy;
+}
+
+export default moveCaret;

package/name.js

@@ -0,0 +1,19 @@
+import { createReducer } from "redux-act";
+import createAction from "../utils/createMetaAction";
+
+// ------------------------------------
+// Actions
+// ------------------------------------
+export const sequenceNameUpdate = createAction("sequenceNameUpdate");
+
+// ------------------------------------
+// Reducer
+// ------------------------------------
+export default createReducer(
+  {
+    [sequenceNameUpdate]: (state, payload) => {
+      return payload;
+    }
+  },
+  "Untitled Sequence"
+);

package/normalizeAngle.js

@@ -0,0 +1,3 @@
+export function normalizeAngle(a) {
+  return (a + Math.PI * 2) % (Math.PI * 2);
+}

package/normalizeAngleRange.js

@@ -0,0 +1,9 @@
+import { normalizeAngle } from "./normalizeAngle";
+
+export function normalizeAngleRange(r) {
+  return {
+    ...r,
+    start: normalizeAngle(r.start),
+    end: normalizeAngle(r.end)
+  };
+}

package/oligoTool.js

@@ -0,0 +1,30 @@
+import { Icon } from "@blueprintjs/core";
+import React from "react";
+import ToolbarItem from "./ToolbarItem";
+import { connectToEditor } from "../withEditorProps";
+
+export default connectToEditor(editorState => {
+  return {
+    isHidden: editorState.sequenceData && editorState.sequenceData.isProtein,
+
+    toggled:
+      editorState.annotationVisibility &&
+      editorState.annotationVisibility.primers
+  };
+})(({ toolbarItemProps, isHidden, toggled, annotationVisibilityToggle }) => {
+  return (
+    <ToolbarItem
+      {...{
+        Icon: <Icon icon="swap-horizontal" />,
+        onIconClick: function () {
+          annotationVisibilityToggle("primers");
+        },
+        isHidden,
+        toggled,
+        tooltip: "Show Primers",
+        tooltipToggled: "Hide Primers",
+        ...toolbarItemProps
+      }}
+    />
+  );
+});

package/onlyUpdateForKeysDeep.js

@@ -0,0 +1,31 @@
+import { pick } from "lodash-es";
+import { shouldUpdate } from "recompose";
+import { isEqualWith, isFunction } from "lodash-es";
+
+// import deepEqual from "deep-equal";
+
+const onlyUpdateForKeys = propKeys => {
+  const hoc = shouldUpdate((props, nextProps) => {
+    const a = !isEq(pick(nextProps, propKeys), pick(props, propKeys));
+    return a;
+  });
+
+  // if (process.env.NODE_ENV !== "production") {
+  //   return BaseComponent =>
+  //     setDisplayName(wrapDisplayName(BaseComponent, "onlyUpdateForKeys"))(
+  //       hoc(BaseComponent)
+  //     );
+  // }
+  return hoc;
+};
+
+export default onlyUpdateForKeys;
+
+const isEq = (o1, o2) => {
+  const isEq = isEqualWith(o1, o2, function (val1, val2) {
+    if (isFunction(val1) && isFunction(val2)) {
+      return val1 === val2 || val1.toString() === val2.toString();
+    }
+  });
+  return isEq;
+};

package/orfFrameToColorMap.js

@@ -0,0 +1,10 @@
+const orfFrameToColorMap = {
+  0: "#FF4040",
+  1: "#5E8804",
+  2: "#17569B"
+};
+export default orfFrameToColorMap;
+
+export const getOrfColor = orf => {
+  return orfFrameToColorMap[orf.frame];
+};