@teselagen/ove 0.0.13 → 0.0.15

package/src/redux/sequenceDataHistory.js

@@ -0,0 +1,43 @@
+//./selectionLayer.js
+import { createReducer } from "redux-act";
+import createAction from "./utils/createMetaAction";
+
+// ------------------------------------
+// Actions
+// ------------------------------------
+export const addToUndoStack = createAction("ADD_TO_UNDO_STACK");
+export const veUndo = createAction("VE_UNDO_META");
+export const veRedo = createAction("VE_REDO_META");
+
+// ------------------------------------
+// Reducer
+// ------------------------------------
+export default createReducer(
+  {
+    [addToUndoStack]: (state, payload) => {
+      return {
+        ...state,
+        future: [],
+        past: [...(state.past||[]), payload]
+      };
+    },
+    [veUndo]: (state, presentState) => {
+      return {
+        ...state,
+        past: (state.past||[]).slice(0, -1),
+        future: (state.future||[]).concat(presentState)
+      };
+    },
+    [veRedo]: (state, presentState) => {
+      return {
+        ...state,
+        future: (state.future||[]).slice(0, -1),
+        past: (state.past||[]).concat(presentState)
+      };
+    }
+  },
+  {
+    past: [],
+    future: []
+  }
+);

package/src/redux/showGCContent.js

@@ -0,0 +1,23 @@
+import { createReducer } from "redux-act";
+
+//./caretPosition.js
+import createAction from "./utils/createMetaAction";
+// import createReducer from "./utils/createMergedDefaultStateReducer";
+
+// ------------------------------------
+// Actions
+// ------------------------------------
+export const toggleShowGCContent = createAction("toggleShowGCContent");
+
+// ------------------------------------
+// Reducer
+// ------------------------------------
+export default createReducer(
+  {
+    [toggleShowGCContent]: (state, val) => {
+      localStorage.setItem("showGCContent", val);
+      return val;
+    }
+  },
+  window.localStorage.getItem("showGCContent")
+);

package/src/redux/toolBar.js

@@ -0,0 +1,25 @@
+import createAction from "./utils/createMetaAction";
+import createMergedDefaultStateReducer from "./utils/createMergedDefaultStateReducer";
+// ------------------------------------
+// Actions
+// ------------------------------------
+export const openToolbarItemUpdate = createAction("openToolbarItemUpdate");
+
+// ------------------------------------
+// Reducer
+// ------------------------------------
+export default createMergedDefaultStateReducer(
+  {
+    
+    [openToolbarItemUpdate]: (state, payload) => {
+      return {
+        ...state,
+        openItem: payload
+      };
+    },
+   
+  },
+  {
+    openItem: "",
+  }
+);

package/src/redux/uppercaseSequenceMapFont.js

@@ -0,0 +1,25 @@
+import { createReducer } from "redux-act";
+
+//./caretPosition.js
+import createAction from "./utils/createMetaAction";
+// import createReducer from "./utils/createMergedDefaultStateReducer";
+
+// ------------------------------------
+// Actions
+// ------------------------------------
+export const updateSequenceCase = createAction("updateSequenceCase");
+
+const newVal = window.localStorage.getItem("uppercaseSequenceMapFont");
+
+// ------------------------------------
+// Reducer
+// ------------------------------------
+export default createReducer(
+  {
+    [updateSequenceCase]: (state, payload) => {
+      localStorage.setItem("uppercaseSequenceMapFont", payload);
+      return payload;
+    }
+  },
+  newVal || "noPreference" //  noPreference || uppercase || lowercase
+);

package/src/redux/useAdditionalOrfStartCodons.js

@@ -0,0 +1,24 @@
+//./caretPosition.js
+import { createReducer } from "redux-act";
+import createAction from "./utils/createMetaAction";
+import { noop } from "lodash";
+
+// ------------------------------------
+// Actions
+// ------------------------------------
+export const useAdditionalOrfStartCodonsToggle = createAction(
+  "useAdditionalOrfStartCodonsToggle",
+  noop
+);
+
+// ------------------------------------
+// Reducer
+// ------------------------------------
+export default createReducer(
+  {
+    [useAdditionalOrfStartCodonsToggle]: state => {
+      return !state;
+    }
+  },
+  false
+);

package/src/redux/utils/addDashesForMatchStartAndEndForTracks/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/src/redux/utils/addMetaToActionCreators.js

@@ -0,0 +1,12 @@
+export default function addMetaToActionCreators(actions, meta) {
+  const metaActions = {};
+  Object.keys(actions).forEach(function (actionName) {
+    metaActions[actionName] = function (firstArg, additionalMeta) {
+      return actions[actionName](firstArg, {
+        ...meta,
+        ...(additionalMeta || {})
+      });
+    };
+  });
+  return metaActions;
+}

package/src/redux/utils/createMergedDefaultStateReducer.js

@@ -0,0 +1,30 @@
+import { createReducer } from "redux-act";
+//simple wrapper function around createReducer to keep around the default state if type === VECTOR_EDITOR_UPDATE or meta.mergeStateDeep=true
+// example:
+// defaultState = {features: true, parts: true}
+// newState = {features: false}
+// stateToUse = {features: false, parts: true}
+// instead of
+// stateToUse = {features: false}
+// these will also be handled differently in the reducer. The __shouldUseMergedState
+// attribute will make them not clear unless full overwritten
+export default function createMergedDefaultStateReducer(
+  handlers,
+  defaultState
+) {
+  const reducer = createReducer(handlers);
+  function enhancedReducer(newState = {}, action) {
+    const stateToUse =
+      action &&
+      (action.type === "VECTOR_EDITOR_UPDATE" ||
+        (action.meta && action.meta.mergeStateDeep))
+        ? {
+            ...defaultState,
+            ...newState
+          }
+        : newState;
+    return reducer(stateToUse, action);
+  }
+  enhancedReducer.__shouldUseMergedState = true;
+  return enhancedReducer;
+}

package/src/redux/utils/createMetaAction.js

@@ -0,0 +1,12 @@
+import { createAction } from "redux-act";
+
+//this makes it so we can call our actionCreator like: 
+//addFeature(myFeatureData, {editorName})
+export default function createMetaAction(actionName, payloadHelper) {
+  return createAction(actionName, payloadHelper, function(unused, meta) {
+    return {
+      ...meta,
+      editorName: meta.editorName
+    };
+  });
+}

package/src/redux/versionHistory.js

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

package/src/selectors/annotationLabelVisibility.js

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

package/src/selectors/annotationSearchSelector.js

@@ -0,0 +1,24 @@
+import { createSelector } from "reselect";
+import { filter } from "lodash";
+export const searchableTypes = ["parts", "features", "primers"];
+
+function annotationSearchSelector(isOpen, searchString, ...rest) {
+  if (!searchString || !isOpen) {
+    return [];
+  }
+  return searchableTypes.map((type, i) => {
+    const annotations = rest[i];
+    return filter(annotations, (ann) =>
+      ann.name
+        .toLowerCase()
+        .includes(searchString ? searchString.toLowerCase() : "")
+    );
+  });
+}
+
+export default createSelector(
+  (state) => state.findTool && state.findTool.isOpen,
+  (state) => state.findTool && state.findTool.searchText,
+  ...searchableTypes.map((type) => (state) => state.sequenceData[type]),
+  annotationSearchSelector
+);

package/src/selectors/cdsFeaturesSelector.js

@@ -0,0 +1,9 @@
+import { createSelector } from "reselect";
+import { filter } from "lodash";
+import featuresSelector from "./featuresSelector";
+
+function cdsFeaturesRawSelector(features) {
+  return filter(features, ({ type }) => type && type.toUpperCase() === "CDS");
+}
+
+export default createSelector(featuresSelector, cdsFeaturesRawSelector);

package/src/selectors/circularSelector.js

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

package/src/selectors/cutsiteLabelColorSelector.js

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

package/src/selectors/cutsitesByRangeSelector.js

@@ -0,0 +1,5 @@
+// import cutsitesSelector from './cutsitesSelector';
+// export default function (state) {
+// 	var {cutsites} = cutsitesSelector(state)
+
+// }

package/src/selectors/cutsitesSelector.js

@@ -0,0 +1,61 @@
+import shortid from "shortid";
+import circularSelector from "./circularSelector";
+import sequenceSelector from "./sequenceSelector";
+import restrictionEnzymesSelector from "./restrictionEnzymesSelector";
+import cutsiteLabelColorSelector from "./cutsiteLabelColorSelector";
+import { createSelector } from "reselect";
+
+import { flatMap as flatmap, map } from "lodash";
+import { getCutsitesFromSequence } from "@teselagen/sequence-utils";
+import { getLowerCaseObj } from "../utils/arrayUtils";
+
+function cutsitesSelector(sequence, circular, enzymeList, cutsiteLabelColors) {
+  //get the cutsites grouped by enzyme
+  const cutsitesByName = getLowerCaseObj(
+    getCutsitesFromSequence(sequence, circular, map(enzymeList))
+  );
+  //tag each cutsite with a unique id
+  const cutsitesById = {};
+  Object.keys(cutsitesByName).forEach(function (enzymeName) {
+    const cutsitesForEnzyme = cutsitesByName[enzymeName];
+    cutsitesForEnzyme.forEach(function (cutsite) {
+      const numberOfCuts = cutsitesByName[enzymeName].length;
+      const uniqueId = shortid();
+      cutsite.id = uniqueId;
+      cutsite.numberOfCuts = numberOfCuts;
+      cutsite.annotationType = "cutsite";
+      cutsitesById[uniqueId] = cutsite;
+      const mergedCutsiteColors = Object.assign(
+        { single: "salmon", double: "lightblue", multi: "lightgrey" },
+        cutsiteLabelColors
+      );
+      if (numberOfCuts === 1) {
+        cutsite.labelColor = mergedCutsiteColors.single;
+        cutsite.labelClassname = "singleCutter";
+      } else if (numberOfCuts === 2) {
+        cutsite.labelColor = mergedCutsiteColors.double;
+        cutsite.labelClassname = "doubleCutter";
+      } else {
+        cutsite.labelColor = mergedCutsiteColors.multi;
+        cutsite.labelClassname = "multiCutter";
+      }
+    });
+  });
+  // create an array of the cutsites
+  const cutsitesArray = flatmap(cutsitesByName, function (cutsitesForEnzyme) {
+    return cutsitesForEnzyme;
+  });
+  return {
+    cutsitesByName,
+    cutsitesById,
+    cutsitesArray
+  };
+}
+
+export default createSelector(
+  sequenceSelector,
+  circularSelector,
+  restrictionEnzymesSelector,
+  cutsiteLabelColorSelector,
+  cutsitesSelector
+);

package/src/selectors/editorSelector.js

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

package/src/selectors/featuresSelector.js

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

package/src/selectors/filteredCutsitesSelector.js

@@ -0,0 +1,137 @@
+import flatmap from "lodash/flatMap";
+import { createSelector } from "reselect";
+import cutsitesSelector from "./cutsitesSelector";
+import filteredRestrictionEnzymesSelector from "./filteredRestrictionEnzymesSelector";
+import specialCutsiteFilterOptions from "../constants/specialCutsiteFilterOptions";
+import { flatMap } from "lodash";
+import isEnzymeFilterAndSelector from "./isEnzymeFilterAndSelector";
+
+export default createSelector(
+  cutsitesSelector,
+  filteredRestrictionEnzymesSelector,
+  isEnzymeFilterAndSelector,
+  (state, addEnzs, enzymeGroupsOverride) => enzymeGroupsOverride,
+  function (
+    { cutsitesByName },
+    filteredRestrictionEnzymes,
+    isEnzymeFilterAnd,
+    enzymeGroupsOverride
+  ) {
+    const returnVal = {
+      cutsitesByName: {}
+    };
+    // const cutsitesByName = getLowerCaseObj(cutsitesByName);
+    const hiddenEnzymesByName = {};
+    let filteredEnzymes = [];
+    let enzymesFromGroups = [];
+    let hasUserGroup;
+    let groupCount = 0;
+    //handle adding enzymes that are included in user created groups
+    filteredRestrictionEnzymes.forEach((e) => {
+      if (e.value.includes("__userCreatedGroup")) {
+        hasUserGroup = true;
+        const existingGroups = {
+          ...window.getExistingEnzymeGroups(),
+          ...enzymeGroupsOverride
+        };
+        const enzymes =
+          existingGroups[e.value.replace("__userCreatedGroup", "")] || [];
+        const zs = flatMap(enzymes, (e) => (e ? { value: e } : []));
+        filteredEnzymes = filteredEnzymes.concat(zs);
+        enzymesFromGroups = enzymesFromGroups.concat(zs);
+        groupCount += 1;
+      } else if (e.isHidden) {
+        hiddenEnzymesByName[e.value] = e;
+      } else {
+        if (!e) return;
+        groupCount += 1;
+        filteredEnzymes.push(e);
+      }
+    });
+    const cutSiteList = [];
+    if (!filteredEnzymes || (filteredEnzymes.length === 0 && !hasUserGroup)) {
+      returnVal.cutsitesByName = cutsitesByName;
+    } else {
+      //loop through each filter option ('Single Cutters', 'BamHI')
+      filteredEnzymes.forEach(function ({ value, ...rest }) {
+        if (!value) {
+          console.error(`Missing value for filtered enzyme`, rest);
+          return;
+        }
+        const lowerValue = value.toLowerCase();
+        const cutsThisManyTimes =
+          specialCutsiteFilterOptions[value] &&
+          specialCutsiteFilterOptions[value].cutsThisManyTimes;
+        if (value === "type2s") {
+          Object.keys(cutsitesByName).forEach(function (key) {
+            if (hiddenEnzymesByName[key]) return; //don't show that cutsite
+            if (
+              cutsitesByName[key].length &&
+              cutsitesByName[key][0]?.restrictionEnzyme?.isType2S
+            ) {
+              cutSiteList.push(key);
+              returnVal.cutsitesByName[key] = cutsitesByName[key];
+            }
+          });
+        } else if (cutsThisManyTimes > 0) {
+          //the cutter type is either 1,2,3 for single, double or triple cutters
+          Object.keys(cutsitesByName).forEach(function (key) {
+            if (hiddenEnzymesByName[key]) return; //don't show that cutsite
+            if (cutsitesByName[key].length === cutsThisManyTimes) {
+              cutSiteList.push(key);
+              returnVal.cutsitesByName[key] = cutsitesByName[key];
+            }
+          });
+        } else {
+          if (hiddenEnzymesByName[lowerValue]) return; //don't show that cutsite
+          //normal enzyme ('BamHI')
+          if (!cutsitesByName[lowerValue]) return;
+          cutSiteList.push(lowerValue);
+          returnVal.cutsitesByName[lowerValue] = cutsitesByName[lowerValue];
+        }
+      });
+    }
+
+    const enzymeCounts = {};
+    cutSiteList.forEach(
+      (enzyme) =>
+        (enzymeCounts[enzyme] = enzymeCounts[enzyme]
+          ? enzymeCounts[enzyme] + 1
+          : 1)
+    );
+
+    const intersectionCutSites = [];
+    Object.keys(enzymeCounts).forEach((key) => {
+      if (enzymeCounts[key] === groupCount) intersectionCutSites.push(key);
+    });
+
+    returnVal.cutsiteIntersectionCount = intersectionCutSites.length;
+
+    const cutsbyname_AND = {};
+    intersectionCutSites.forEach((value) => {
+      cutsbyname_AND[value] = cutsitesByName[value];
+    });
+
+    returnVal.cutsiteTotalCount = Object.keys(returnVal.cutsitesByName).length;
+
+    if (isEnzymeFilterAnd && returnVal.cutsiteIntersectionCount > 0) {
+      returnVal.cutsitesByName = cutsbyname_AND;
+    }
+
+    returnVal.cutsitesArray = flatmap(
+      returnVal.cutsitesByName,
+      (cutsitesByNameArray) => cutsitesByNameArray
+    );
+    returnVal.cutsitesById = returnVal.cutsitesArray.reduce(function (
+      obj,
+      item
+    ) {
+      if (item && item.id) {
+        obj[item.id] = item;
+      }
+      return obj;
+    },
+    {});
+    return returnVal;
+  }
+);

package/src/selectors/filteredFeaturesSelector.js

@@ -0,0 +1,32 @@
+import { createSelector } from "reselect";
+import { omitBy } from "lodash";
+import featuresSelector from "./featuresSelector";
+import sequenceLengthSelector from "./sequenceLengthSelector";
+import { hideAnnByLengthFilter } from "../utils/editorUtils";
+
+function filteredFeaturesSelector(
+  features,
+  seqLen,
+  featureIndividualToHide,
+  featureTypesToHide,
+  lengthsToHide
+) {
+  return omitBy(features, (ann) => {
+    const hideIndividually = featureIndividualToHide[ann.id];
+    const hideFeaturesByType = featureTypesToHide[ann.type];
+    return (
+      hideAnnByLengthFilter(lengthsToHide, ann, seqLen) ||
+      hideFeaturesByType ||
+      hideIndividually
+    );
+  });
+}
+
+export default createSelector(
+  featuresSelector,
+  sequenceLengthSelector,
+  (state) => state.annotationVisibility.featureIndividualToHide,
+  (state) => state.annotationVisibility.featureTypesToHide,
+  (state) => state.featureLengthsToHide,
+  filteredFeaturesSelector
+);

package/src/selectors/filteredPartsSelector.js

@@ -0,0 +1,57 @@
+import { createSelector } from "reselect";
+import partsSelector from "./partsSelector";
+import tagsToBoldSelector from "./tagsToBoldSelector";
+import { some, keyBy, omitBy } from "lodash";
+import { map } from "lodash";
+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
+);