@teselagen/ove 0.7.28 → 0.7.30-beta.1

package/alignments.js

@@ -1,379 +0,0 @@
-import {
-  tidyUpSequenceData /* generateSequenceData */,
-  condensePairwiseAlignmentDifferences
-} from "@teselagen/sequence-utils";
-import { convertBasePosTraceToPerBpTrace } from "@teselagen/bio-parsers";
-import shortid from "shortid";
-
-import addDashesForMatchStartAndEndForTracks from "./utils/addDashesForMatchStartAndEndForTracks";
-
-import { /* createReducer, */ createAction } from "redux-act";
-import { omit } from "lodash-es";
-
-const alignmentAnnotationSettings = {
-  axis: true,
-  axisNumbers: true,
-  chromatogram: false,
-  dnaColors: false,
-  features: false,
-  parts: false,
-  reverseSequence: false,
-  sequence: true,
-  translations: true,
-  orfs: false,
-  orfTranslations: false,
-  cdsFeatureTranslations: false,
-  cutsites: false,
-  primers: false,
-  compactNames: false
-};
-
-const defaultVisibilities = {
-  alignmentAnnotationVisibility: alignmentAnnotationSettings,
-  pairwise_alignmentAnnotationVisibility: alignmentAnnotationSettings,
-  alignmentAnnotationLabelVisibility: {
-    features: false,
-    parts: false,
-    cutsites: false
-  },
-  pairwise_alignmentAnnotationLabelVisibility: {
-    features: false,
-    parts: false,
-    cutsites: false
-  }
-};
-const defaultVisibilityTypes = Object.keys(defaultVisibilities);
-
-try {
-  defaultVisibilityTypes.forEach(type => {
-    const newVal = JSON.parse(window.localStorage.getItem(type));
-    if (newVal)
-      defaultVisibilities[type] = {
-        ...defaultVisibilities[type],
-        ...newVal
-      };
-  });
-} catch (e) {
-  console.error("error setting localstorage visibility config", e);
-}
-
-// ------------------------------------
-// Actions
-// ------------------------------------
-export const upsertAlignmentRun = createAction("UPSERT_ALIGNMENT_RUN");
-export const removeAlignmentFromRedux = createAction(
-  "REMOVE_ALIGNMENT_FROM_REDUX"
-);
-export const updateAlignmentViewVisibility = createAction(
-  "UPDATE_ALIGNMENT_VIEW_VISIBILITY"
-);
-export const alignmentRunUpdate = createAction("ALIGNMENT_RUN_UPDATE");
-
-const highlightRangeProps = {
-  color: "red",
-  hideCarets: true,
-  ignoreGaps: true
-};
-function addHighlightedDifferences(alignmentTracks) {
-  return alignmentTracks.map(track => {
-    if (track.isUnmapped) {
-      return track;
-    }
-    const sequenceData = tidyUpSequenceData(track.sequenceData, {
-      doNotRemoveInvalidChars: true
-    });
-    const matchHighlightRanges = getRangeMatchesBetweenTemplateAndNonTemplate(
-      alignmentTracks[0].alignmentData.sequence,
-      track.alignmentData.sequence
-    );
-    // .filter by the user-specified mismatch overrides (initially [])
-    const mismatches = matchHighlightRanges.filter(({ isMatch }) => !isMatch);
-    return {
-      ...track,
-      sequenceData,
-      matchHighlightRanges,
-      additionalSelectionLayers: matchHighlightRanges
-        .filter(({ isMatch }) => !isMatch)
-        .map(range => {
-          return { ...range, ...highlightRangeProps };
-        }),
-      mismatches
-    };
-  });
-}
-
-// alignmentTracks = addHighlightedDifferences(alignmentTracks);
-
-// ------------------------------------
-// Reducer
-// ------------------------------------
-
-export default (state = {}, { payload = {}, type }) => {
-  if (type === "ALIGNMENT_RUN_UPDATE") {
-    const { alignmentId } = payload;
-    const newState = {
-      ...state,
-      [alignmentId]: {
-        ...state[alignmentId],
-        ...payload
-      }
-    };
-    return newState;
-  }
-
-  if (type === "UPDATE_ALIGNMENT_VIEW_VISIBILITY") {
-    defaultVisibilityTypes.forEach(type => {
-      if (
-        (type.startsWith("pairwise_") && payload.pairwiseAlignments) ||
-        (!type.startsWith("pairwise_") && !payload.pairwiseAlignments)
-      ) {
-        defaultVisibilities[type] = {
-          ...defaultVisibilities[type],
-          ...payload[type.replace("pairwise_", "")]
-        };
-
-        localStorage.setItem(
-          type,
-          JSON.stringify({
-            ...defaultVisibilities[type],
-            ...payload[type.replace("pairwise_", "")]
-          })
-        );
-      }
-    });
-    return {
-      ...state,
-      [payload.id]: { ...payload }
-    };
-  }
-  if (type === "UPSERT_ALIGNMENT_RUN") {
-    const { id } = payload;
-    const payloadToUse = {
-      stateTrackingId: state[id]?.stateTrackingId ? shortid() : "initialLoadId",
-      alignmentType: state[id]?.alignmentType,
-      ...payload,
-      //assign default visibilities
-      ...defaultVisibilityTypes.reduce((acc, type) => {
-        if (
-          (type.startsWith("pairwise_") && payload.pairwiseAlignments) ||
-          (!type.startsWith("pairwise_") && !payload.pairwiseAlignments)
-        ) {
-          acc[type.replace("pairwise_", "")] = {
-            ...defaultVisibilities[type],
-            ...payload[type.replace("pairwise_", "")]
-          };
-        }
-        return acc;
-      }, {})
-    };
-    if (payloadToUse.pairwiseAlignments) {
-      if (
-        payloadToUse.pairwiseAlignments[0][0].alignmentData.matchStart !==
-        undefined
-      ) {
-        payloadToUse.pairwiseAlignments = payloadToUse.pairwiseAlignments.map(
-          addDashesForMatchStartAndEndForTracks
-        );
-      }
-      const templateSeq = payloadToUse.pairwiseAlignments[0][0];
-      //we need to get all of the sequences in a single alignment (turning inserts into single BP red highlights)
-      const pairwiseOverviewAlignmentTracks = [
-        {
-          //add the template seq as the first track in the Pairwise Alignment Overview
-          ...templateSeq,
-          sequenceData: tidyUpSequenceData(templateSeq.sequenceData, {
-            doNotRemoveInvalidChars: true
-          }),
-          alignmentData: { sequence: templateSeq.sequenceData.sequence } //remove the gaps from the template sequence
-        }
-      ]; // start with just the template seq in there!
-
-      payloadToUse.pairwiseAlignments.forEach(([template, alignedSeq]) => {
-        const condensedSeq = condensePairwiseAlignmentDifferences(
-          template.alignmentData.sequence,
-          alignedSeq.alignmentData.sequence
-        );
-        let re = /r+/gi;
-        let match;
-        const additionalSelectionLayers = [];
-        while ((match = re.exec(condensedSeq)) != null) {
-          additionalSelectionLayers.push({
-            start: match.index,
-            end: match.index + match[0].length - 1,
-            ...highlightRangeProps
-          });
-        }
-        re = /g+/gi;
-        // let match;
-        while ((match = re.exec(condensedSeq)) != null) {
-          additionalSelectionLayers.push({
-            start: match.index,
-            end: match.index + match[0].length - 1,
-            ...highlightRangeProps,
-            color: "grey"
-          });
-        }
-
-        const alignedSeqMinusInserts = {
-          ...alignedSeq,
-          sequenceData: {
-            ...tidyUpSequenceData(alignedSeq.sequenceData, {
-              doNotRemoveInvalidChars: true
-            }),
-            sequence: template.sequenceData.sequence
-          },
-          additionalSelectionLayers,
-          alignmentData: {
-            sequence: condensedSeq
-          }
-        };
-        pairwiseOverviewAlignmentTracks.push(alignedSeqMinusInserts);
-      });
-      payloadToUse.pairwiseOverviewAlignmentTracks =
-        pairwiseOverviewAlignmentTracks;
-      payloadToUse.pairwiseAlignments = payloadToUse.pairwiseAlignments.map(
-        addHighlightedDifferences
-      );
-    }
-    if (payloadToUse.alignmentTracks) {
-      payloadToUse.alignmentTracks = addHighlightedDifferences(
-        payloadToUse.alignmentTracks
-      );
-    }
-    //check for issues
-    let hasError = checkForIssues(
-      payloadToUse.alignmentTracks,
-      payload.alignmentType
-    );
-    (payloadToUse.pairwiseAlignments || []).forEach(alignment => {
-      const error = alignment;
-      if (error) {
-        hasError = error;
-      }
-    });
-    return {
-      ...state,
-      [payload.id]: {
-        ...payloadToUse,
-        hasError
-      }
-    };
-  }
-  if (type === "REMOVE_ALIGNMENT_FROM_REDUX") {
-    const { id } = payload;
-    state = omit(state, [id]);
-  }
-  return state;
-};
-
-//returns an array like so: [{start: 0, end: 4, isMatch: false}, {start,end,isMatch} ... etc]
-function getRangeMatchesBetweenTemplateAndNonTemplate(tempSeq, nonTempSeq) {
-  //assume all sequences are the same length (with gap characters "-" in some places)
-  //loop through all non template sequences and compare them with the template
-
-  const seqLength = nonTempSeq.length;
-  const ranges = [];
-  // const startIndex = "".match/[-]/ Math.max(0, .indexOf("-"));
-  const nonTempSeqWithoutLeadingDashes = nonTempSeq.replace(/^-+/g, "");
-  const nonTempSeqWithoutTrailingDashes = nonTempSeq.replace(/-+$/g, "");
-
-  const startIndex = seqLength - nonTempSeqWithoutLeadingDashes.length;
-  const endIndex =
-    seqLength - (seqLength - nonTempSeqWithoutTrailingDashes.length);
-  for (let index = startIndex; index < endIndex; index++) {
-    const isMatch =
-      tempSeq[index].toLowerCase() === nonTempSeq[index].toLowerCase();
-    const previousRange = ranges[ranges.length - 1];
-    if (previousRange) {
-      if (previousRange.isMatch === isMatch) {
-        previousRange.end++;
-      } else {
-        ranges.push({
-          start: index,
-          end: index,
-          isMatch
-        });
-      }
-    } else {
-      ranges.push({
-        start: startIndex,
-        end: startIndex,
-        isMatch
-      });
-    }
-  }
-  return ranges;
-}
-
-function checkForIssues(alignmentTracks, alignmentType) {
-  if (
-    !alignmentTracks ||
-    !alignmentTracks[0] ||
-    !alignmentTracks[0].alignmentData
-  ) {
-    return;
-  }
-
-  const alignmentTrackLength = alignmentTracks[0].alignmentData.sequence.length;
-  let hasError;
-  alignmentTracks.some(track => {
-    if (track.alignmentData.sequence.length !== alignmentTrackLength) {
-      console.error("incorrect length", alignmentTracks);
-
-      return "incorrect length";
-    }
-    if (
-      track.chromatogramData &&
-      track.sequenceData.sequence.length !==
-        track.chromatogramData.baseCalls.length
-    ) {
-      console.error("incorrect chromatogram length", alignmentTracks);
-
-      return "incorrect chromatogram length";
-    }
-    if (track.chromatogramData && !track.chromatogramData.baseTraces) {
-      if (!track.chromatogramData.basePos) {
-        console.error("corrupted chromatogram data", alignmentTracks);
-        return "corrupted chromatogram data";
-      }
-      track.chromatogramData = convertBasePosTraceToPerBpTrace(
-        track.chromatogramData
-      );
-    }
-    if (
-      alignmentType !== "Parallel Part Creation" &&
-      track.sequenceData.sequence.length !==
-        track.alignmentData.sequence.replace(/-/g, "").length
-    ) {
-      console.error(
-        "sequence data length does not match alignment data w/o gaps"
-      );
-      console.error(
-        "track.sequenceData.sequence:",
-        track.sequenceData.sequence
-      );
-      console.error(
-        "track.sequenceData.sequence.length:",
-        track.sequenceData.sequence.length
-      );
-      console.error(
-        "track.alignmentData.sequence:",
-        track.alignmentData.sequence
-      );
-      console.error(
-        'track.alignmentData.sequence.replace(/-/g,""):',
-        track.alignmentData.sequence.replace(/-/g, "")
-      );
-      console.error(
-        'track.alignmentData.sequence.replace(/-/g,"").length:',
-        track.alignmentData.sequence.replace(/-/g, "").length
-      );
-      hasError = "sequence data length does not match alignment data w/o gaps";
-      return true;
-    }
-    return false;
-  });
-  if (hasError) {
-    return hasError;
-  }
-}

package/annotationLabelVisibility.js

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

package/annotationSearchSelector.js

@@ -1,24 +0,0 @@
-import { createSelector } from "reselect";
-import { filter } from "lodash-es";
-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/annotationTypes.js

@@ -1,35 +0,0 @@
-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/annotationVisibility.js

@@ -1,196 +0,0 @@
-import { omit } from "lodash-es";
-
-//./caretPosition.js
-
-import createAction from "./utils/createMetaAction";
-import createMergedDefaultStateReducer from "./utils/createMergedDefaultStateReducer";
-
-export const visibilityDefaultValues = {
-  featureTypesToHide: {},
-  featureIndividualToHide: {},
-  partIndividualToHide: {},
-  primerIndividualToHide: {},
-  features: true,
-  warnings: true,
-  assemblyPieces: true,
-  chromatogram: true,
-  lineageAnnotations: true,
-  translations: true,
-  parts: true,
-  orfs: false,
-  orfTranslations: false,
-  cdsFeatureTranslations: true,
-  axis: true,
-  cutsites: true,
-  // cutsites: true,
-  cutsitesInSequence: true,
-  primers: true,
-  dnaColors: false,
-  sequence: true,
-  reverseSequence: true,
-  fivePrimeThreePrimeHints: true,
-  axisNumbers: true
-};
-
-// ------------------------------------
-// Actions
-// ------------------------------------
-export const annotationVisibilityToggle = createAction(
-  "annotationVisibilityToggle"
-);
-//eg: annotationVisibilityToggle('features')
-export const annotationVisibilityHide = createAction(
-  "annotationVisibilityHide"
-);
-export const annotationVisibilityShow = createAction(
-  "annotationVisibilityShow"
-);
-export const hideFeatureTypes = createAction("hideFeatureTypes");
-export const showFeatureTypes = createAction("showFeatureTypes");
-export const resetFeatureTypesToHide = createAction("resetFeatureTypesToHide");
-export const hideFeatureIndividual = createAction("hideFeatureIndividual");
-export const showFeatureIndividual = createAction("showFeatureIndividual");
-export const resetFeatureIndividualToHide = createAction(
-  "resetFeatureIndividualToHide"
-);
-export const hidePrimerIndividual = createAction("hidePrimerIndividual");
-export const showPrimerIndividual = createAction("showPrimerIndividual");
-export const resetPrimerIndividualToHide = createAction(
-  "resetPrimerIndividualToHide"
-);
-export const hidePartIndividual = createAction("hidePartIndividual");
-export const showPartIndividual = createAction("showPartIndividual");
-export const resetPartIndividualToHide = createAction(
-  "resetPartIndividualToHide"
-);
-
-// ------------------------------------
-// Reducer
-// ------------------------------------
-const annotationVisibility = createMergedDefaultStateReducer(
-  {
-    [resetPartIndividualToHide]: state => {
-      return {
-        ...state,
-        partIndividualToHide: {}
-      };
-    },
-    [showPartIndividual]: (state, payload) => {
-      return {
-        ...state,
-        parts: true,
-        partIndividualToHide: omit(state.partIndividualToHide, payload)
-      };
-    },
-    [hidePartIndividual]: (state, payload) => {
-      return {
-        ...state,
-        partIndividualToHide: {
-          ...state.partIndividualToHide,
-          ...payload.reduce((acc, key) => {
-            acc[key] = true;
-            return acc;
-          }, {})
-        }
-      };
-    },
-    [resetFeatureIndividualToHide]: state => {
-      return {
-        ...state,
-        featureIndividualToHide: {}
-      };
-    },
-    [showFeatureIndividual]: (state, payload) => {
-      return {
-        ...state,
-        features: true,
-        featureIndividualToHide: omit(state.featureIndividualToHide, payload)
-      };
-    },
-    [hideFeatureIndividual]: (state, payload) => {
-      return {
-        ...state,
-        featureIndividualToHide: {
-          ...state.featureIndividualToHide,
-          ...payload.reduce((acc, key) => {
-            acc[key] = true;
-            return acc;
-          }, {})
-        }
-      };
-    },
-    [resetPrimerIndividualToHide]: state => {
-      return {
-        ...state,
-        primerIndividualToHide: {}
-      };
-    },
-    [showPrimerIndividual]: (state, payload) => {
-      return {
-        ...state,
-        primers: true,
-        primerIndividualToHide: omit(state.primerIndividualToHide, payload)
-      };
-    },
-    [hidePrimerIndividual]: (state, payload) => {
-      return {
-        ...state,
-        primerIndividualToHide: {
-          ...state.primerIndividualToHide,
-          ...payload.reduce((acc, key) => {
-            acc[key] = true;
-            return acc;
-          }, {})
-        }
-      };
-    },
-    [resetFeatureTypesToHide]: state => {
-      return {
-        ...state,
-        featureTypesToHide: {}
-      };
-    },
-    [showFeatureTypes]: (state, payload) => {
-      return {
-        ...state,
-        featureTypesToHide: omit(state.featureTypesToHide, payload)
-      };
-    },
-    [hideFeatureTypes]: (state, payload) => {
-      return {
-        ...state,
-        featureTypesToHide: {
-          ...state.featureTypesToHide,
-          ...payload.reduce((acc, key) => {
-            acc[key] = true;
-            return acc;
-          }, {})
-        }
-      };
-    },
-    [annotationVisibilityToggle]: (state, payload) => {
-      return {
-        ...state,
-        [payload]: !state[payload],
-        ...(payload === "orfs" && state.orfs === state.orfTranslations
-          ? { orfTranslations: !state.orfTranslations }
-          : null)
-      };
-    },
-    [annotationVisibilityHide]: (state, payload) => {
-      return {
-        ...state,
-        [payload]: false
-      };
-    },
-    [annotationVisibilityShow]: (state, payload) => {
-      return {
-        ...state,
-        [payload]: true
-      };
-    }
-  },
-  visibilityDefaultValues
-);
-
-export default annotationVisibility;