@opencloning/store 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# @opencloning/store
+
+## 1.0.0
+
+### Major Changes
+
+- babe2f9: Switch to monorepo structure and use changesets
+
+### Minor Changes
+
+- 8cd33bb: Rearrange dependencies

package/package.json

@@ -0,0 +1,28 @@
+{
+    "name": "@opencloning/store",
+    "version": "1.0.0",
+    "type": "module",
+    "main": "./src/index.js",
+    "exports": {
+        ".": "./src/index.js",
+        "./cloning": "./src/cloning.js",
+        "./cloning_utils": "./src/cloning_utils.js"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/manulera/OpenCloning_frontend.git",
+        "directory": "packages/store"
+    },
+    "dependencies": {
+        "@reduxjs/toolkit": "^1.9.7",
+        "@teselagen/bio-parsers": "^0.4.32",
+        "@teselagen/range-utils": "^0.3.13",
+        "redux": "^4.2.1",
+        "redux-form": "^8.3.10",
+        "redux-thunk": "^2.4.2"
+    },
+    "peerDependencies": {
+        "react": "^18.3.1",
+        "react-redux": "^8.1.3"
+    }
+}

package/src/cloning.js

@@ -0,0 +1,456 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { doesSourceHaveOutput, getNextUniqueId } from './cloning_utils';
+import { convertToTeselaJson } from '@opencloning/utils/readNwrite';
+
+function deleteFilesFromSessionStorage(sequenceId, fileName = null) {
+  Object.keys(sessionStorage)
+    .filter((key) => {
+      let query = `verification-${sequenceId}-`;
+      if (fileName) {
+        query += fileName;
+      }
+      return key.startsWith(query);
+    }).forEach((key) => sessionStorage.removeItem(key));
+}
+
+const initialState = {
+  mainSequenceId: null,
+  mainSequenceSelection: {},
+  sources: [
+    {
+      id: 1,
+      input: [],
+      type: null,
+    },
+  ],
+  sequences: [],
+  network: null,
+  currentTab: 0,
+  description: '',
+  selectedRegions: [],
+  knownErrors: {},
+  primers: [],
+  config: {
+    loaded: false,
+    backendUrl: null,
+    enableAssembler: false,
+    enablePlannotate: false,
+  },
+  sourcesWithHiddenAncestors: [],
+  teselaJsonCache: {},
+  alerts: [],
+  files: [],
+  appInfo: {},
+  // Global primer design settings affecting Tm calculations
+  globalPrimerSettings: {
+    primer_dna_conc: 50, // default 50 nM
+    primer_salt_monovalent: 50, // e.g. Na+ / K+
+    primer_salt_divalent: 1.5, // e.g. Mg2+
+  },
+};
+
+ 
+const reducer = {
+
+  setCurrentTab(state, action) {
+    state.currentTab = action.payload;
+  },
+
+  setMainSequenceId(state, action) {
+    state.mainSequenceId = action.payload;
+    state.mainSequenceSelection = {};
+  },
+
+  setMainSequenceSelection(state, action) {
+    state.mainSequenceSelection = action.payload;
+  },
+
+  addEmptySource(state, action) {
+    const inputSequencesIds = action.payload;
+    const { sources } = state;
+    const nextUniqueId = getNextUniqueId(state);
+    sources.push({
+      id: nextUniqueId,
+      input: inputSequencesIds.map((id) => ({ sequence: id })),
+      type: null,
+    });
+  },
+
+  restoreSource(state, action) {
+    // This is used to roll back a source that was deleted
+    const source = action.payload;
+    const { sources } = state;
+    sources.push(source);
+  },
+
+  addTemplateChildAndSubsequentSource(state, action) {
+    // This is used by the Hom. Rec. primer design. You pass a
+    // sourceId for which you want to add a template sequence as
+    // an output, and then a source that will take that template
+    // sequence as input. The source can also have existing sequences
+    // as input.
+    const { sourceId, newSequence, newSource } = action.payload;
+    const { sources, sequences } = state;
+    const source2update = sources.find((s) => s.id === sourceId);
+    if (source2update === undefined) {
+      throw new Error('Source not found');
+    }
+
+    // Add the template sequence
+    sequences.push({
+      id: sourceId,
+      ...newSequence,
+    });
+
+    // Add the source that will take the template sequence as input
+    sources.push({
+      id: getNextUniqueId(state),
+      ...newSource,
+      input: [...(newSource.input || []), { sequence: sourceId }],
+    });
+  },
+
+  addPCRsAndSubsequentSourcesForAssembly(state, action) {
+    // This is used by the PCR primer design for Gibson Assemblies. You pass a
+    // sourceId (PCR from which the primer design was started),
+    // and a list of templateIds to be amplified by PCR. Their outputs
+    // will be used as input for a subsequent assembly reaction.
+    const { sourceId, templateIds, sourceType, newSequence } = action.payload;
+    const { sources, sequences } = state;
+
+    if (sources.find((s) => s.id === sourceId) === undefined) {
+      throw new Error('Source not found');
+    }
+    const sources2update = [sourceId];
+    // Add the PCR sources
+    templateIds.forEach((templateId) => {
+      const nextId = getNextUniqueId(state);
+      const newSource = {
+        id: nextId,
+        input: [{ sequence: templateId }],
+        type: 'PCRSource',
+      };
+      sources.push(newSource);
+      sources2update.push(newSource.id);
+    });
+
+    // Add the output sequences
+    sources2update.forEach((id) => {
+      sequences.push({
+        ...newSequence,
+        id,
+      });
+    });
+
+    if (sourceType !== null) {
+      // Add the Assembly that takes the PCR outputs as input
+      sources.push({
+        id: getNextUniqueId(state),
+        input: sources2update.map((id) => ({ sequence: id })),
+        type: sourceType,
+      });
+    }
+  },
+
+  addSourceAndItsOutputSequence(state, action) {
+    const { source, sequence } = action.payload;
+    const { sources, sequences } = state;
+
+    const sourceId = getNextUniqueId(state);
+    const sequenceId = sourceId;
+    const newSequence = {
+      ...sequence,
+      id: sequenceId,
+    };
+    const newSource = {
+      ...source,
+      id: sourceId
+    };
+    sequences.push(newSequence);
+    sources.push(newSource);
+    state.teselaJsonCache[sequenceId] = convertToTeselaJson(newSequence);
+  },
+
+  addSequenceInBetween(state, action) {
+    const existingSourceId = action.payload;
+    const existingSource = state.sources.find((s) => s.id === existingSourceId);
+    const newSourceId = getNextUniqueId(state);
+    const newSequence = {
+      id: newSourceId,
+      type: 'TemplateSequence',
+    };
+    const newSource = {
+      id: newSourceId,
+      input: existingSource.input,
+      type: null,
+    };
+    existingSource.input = [{ sequence: newSequence.id }];
+    state.sources.push(newSource);
+    state.sequences.push(newSequence);
+  },
+
+  addSequenceAndUpdateItsSource(state, action) {
+    const { newSequence, newSource } = action.payload;
+    const { sequences, sources } = state;
+    newSequence.id = newSource.id;
+
+    const sourceIndex = sources.findIndex((s) => s.id === newSource.id);
+    if (sourceIndex === -1) {
+      throw new Error('Source not found');
+    }
+    sources.splice(sourceIndex, 1, newSource);
+    sequences.push(newSequence);
+    state.teselaJsonCache[newSequence.id] = convertToTeselaJson(newSequence);
+  },
+
+  updateSequenceAndItsSource(state, action) {
+    const { newSequence, newSource } = action.payload;
+    const { sequences, sources } = state;
+
+    const sourceIndex = sources.findIndex((s) => s.id === newSource.id);
+    if (sourceIndex === -1) {
+      throw new Error('Source not found');
+    }
+    sources.splice(sourceIndex, 1, newSource);
+
+    newSequence.id = newSource.id;
+    const sequenceIndex = sequences.findIndex((e) => e.id === newSequence.id);
+    if (sequenceIndex === -1) {
+      throw new Error('Sequence not found');
+    }
+    sequences.splice(sequenceIndex, 1, newSequence);
+    state.teselaJsonCache[newSequence.id] = convertToTeselaJson(newSequence);
+  },
+
+  updateSource(state, action) {
+    const newSource = action.payload;
+    const { sources } = state;
+    const source = sources.find((s) => s.id === newSource.id);
+    Object.assign(source, newSource);
+  },
+
+  updateSequence(state, action) {
+    const newSequence = action.payload;
+    const { sequences } = state;
+    const sequence = sequences.find((s) => s.id === newSequence.id);
+    Object.assign(sequence, newSequence);
+    state.teselaJsonCache[newSequence.id] = convertToTeselaJson(newSequence);
+  },
+
+  replaceSource(state, action) {
+    const newSource = action.payload;
+    const { sources } = state;
+    const sourceIndex = sources.findIndex((s) => s.id === newSource.id);
+    if (sourceIndex === -1) {
+      throw new Error('Source not found');
+    }
+    sources.splice(sourceIndex, 1, newSource);
+  },
+
+  deleteSourceAndItsChildren(state, action) {
+    const sourceId = action.payload;
+    const { sources, sequences } = state;
+    const sources2delete = [];
+    const sequences2delete = [];
+    const currentSources = [sources.find((s) => s.id === sourceId)];
+    while (currentSources.length > 0) {
+      const currentSource = currentSources.pop();
+      sources2delete.push(currentSource.id);
+      if (doesSourceHaveOutput(state, currentSource.id)) {
+        sequences2delete.push(currentSource.id);
+        currentSources.push(...sources.filter((ss) => ss.input.some(({sequence}) => sequence === currentSource.id)));
+      }
+    }
+    state.sources = sources.filter((s) => !sources2delete.includes(s.id));
+    state.sequences = sequences.filter((e) => !sequences2delete.includes(e.id));
+    state.files = state.files.filter((f) => !sequences2delete.includes(f.sequence_id));
+    sequences2delete.forEach((e) => {
+      delete state.teselaJsonCache[e];
+      deleteFilesFromSessionStorage(e);
+    });
+  },
+
+  setState(state, action) {
+    const { sources, sequences, primers, description, files, sourcesWithHiddenAncestors } = action.payload;
+    if (!Array.isArray(sources) || !Array.isArray(sequences)) {
+      throw new Error('Cloning strategy not valid: fields `sources` and `sequences` should exist and be arrays');
+    }
+    const ids = [...sources.map((s) => s.id), ...sequences.map((e) => e.id)];
+    // They should all be positive integers
+    if (ids.some((id) => id < 1 || !Number.isInteger(id))) {
+      throw new Error('Some ids are not positive integers');
+    }
+    // None should be repeated
+    const sourceIds = sources.map((s) => s.id);
+    const sequenceIds = sequences.map((e) => e.id);
+    if (new Set(sourceIds).size !== sourceIds.length || new Set(sequenceIds).size !== sequenceIds.length) {
+      throw new Error('Repeated ids in sources or sequences');
+    }
+    state.sources = sources;
+    state.sequences = sequences;
+    state.teselaJsonCache = {};
+    state.primers = primers || [];
+    state.description = description || '';
+    state.files = files || [];
+    state.sourcesWithHiddenAncestors = sourcesWithHiddenAncestors || [];
+    sequences.forEach((e) => {
+      if (e.type === 'TextFileSequence') {
+        state.teselaJsonCache[e.id] = convertToTeselaJson(e);
+      }
+    });
+  },
+
+  setDescription(state, action) {
+    state.description = action.payload;
+  },
+
+  setSelectedRegions(state, action) {
+    state.selectedRegions = [...action.payload];
+  },
+
+  setKnownErrors(state, action) {
+    state.knownErrors = action.payload;
+  },
+
+  setConfig(state, action) {
+    Object.assign(state.config, action.payload);
+    state.config.loaded = true;
+  },
+
+  addPrimer(state, action) {
+    const primer = action.payload;
+    const { primers } = state;
+    const nextPrimerId = getNextUniqueId(state);
+    primers.push({ ...primer, id: nextPrimerId });
+  },
+
+  setPrimers(state, action) {
+    const primers = action.payload;
+    // Ids are unique and all are positive integers
+    const ids = primers.map((p) => p.id);
+    if (ids.some((id) => id < 1 || !Number.isInteger(id))) {
+      throw new Error('Some ids are not positive integers');
+    }
+    // None should be repeated
+    if (new Set(ids).size !== ids.length) {
+      throw new Error('Repeated ids in the primers');
+    }
+    state.primers = primers;
+  },
+
+  deletePrimer(state, action) {
+    const primerId = action.payload;
+    state.primers = state.primers.filter((p) => p.id !== primerId);
+  },
+
+  editPrimer(state, action) {
+    const editedPrimer = action.payload;
+    const targetPrimer = state.primers.find((p) => p.id === editedPrimer.id);
+    if (!targetPrimer) {
+      throw new Error('Primer not found');
+    }
+    Object.assign(targetPrimer, editedPrimer);
+  },
+
+  addPrimersToPCRSource(state, action) {
+    const { sourceId, fwdPrimer, revPrimer } = action.payload;
+    const { sources, primers } = state;
+    const nextId = getNextUniqueId(state);
+    // For now, primers were coming with id=0 from the backend
+    const copyFwdPrimer = { ...fwdPrimer };
+    const copyRevPrimer = { ...revPrimer };
+    copyFwdPrimer.id = nextId;
+    copyRevPrimer.id = nextId + 1;
+    primers.push(copyFwdPrimer);
+    primers.push(copyRevPrimer);
+
+    const source = sources.find((s) => s.id === sourceId);
+    if (!source) {
+      throw new Error('Source not found');
+    }
+    source.input = [ {sequence: nextId}, ...source.input, {sequence: nextId + 1} ];
+  },
+
+  addToSourcesWithHiddenAncestors(state, action) {
+    const sourceId = action.payload;
+    state.sourcesWithHiddenAncestors.push(sourceId);
+  },
+
+  removeFromSourcesWithHiddenAncestors(state, action) {
+    const sourceId = action.payload;
+    state.sourcesWithHiddenAncestors = state.sourcesWithHiddenAncestors.filter((id) => id !== sourceId);
+  },
+
+  addAlert(state, action) {
+    state.alerts.push(action.payload);
+  },
+
+  removeAlert(state, action) {
+    const message = action.payload;
+    state.alerts = state.alerts.filter((a) => a.message !== message);
+  },
+
+  addFile(state, action) {
+    state.files.push(action.payload);
+  },
+
+  setFiles(state, action) {
+    state.files = action.payload;
+  },
+
+  removeFile(state, action) {
+    const { fileName, sequenceId } = action.payload;
+    state.files = state.files.filter((f) => f.file_name !== fileName || f.sequence_id !== sequenceId);
+  },
+
+  removeFilesAssociatedToSequence(state, action) {
+    const sequenceId = action.payload;
+    state.files = state.files.filter((f) => f.sequence_id !== sequenceId);
+    deleteFilesFromSessionStorage(sequenceId);
+  },
+
+  addDatabaseIdToSequence(state, action) {
+    const { databaseId, id } = action.payload;
+    const sequence = state.sequences.find((e) => e.id === id);
+    if (!sequence) {
+      throw new Error('Sequence not found');
+    }
+    const source = state.sources.find((s) => s.id === id);
+    if (!source) {
+      throw new Error('Source not found');
+    }
+    source.database_id = databaseId;
+  },
+  addDatabaseIdToPrimer(state, action) {
+    const { databaseId, localId } = action.payload;
+    const primer = state.primers.find((p) => p.id === localId);
+    if (!primer) {
+      throw new Error('Primer not found');
+    }
+    primer.database_id = databaseId;
+  },
+
+  updateAppInfo(state, action) {
+    state.appInfo = { ...state.appInfo, ...action.payload };
+  },
+
+  // Update global primer settings
+  setGlobalPrimerSettings(state, action) {
+    const updates = action.payload;
+    state.globalPrimerSettings = {
+      ...state.globalPrimerSettings,
+      ...updates,
+    };
+  },
+};
+
+ 
+
+const cloningSlice = createSlice({
+  name: 'cloning',
+  initialState: { ...initialState },
+  reducers: reducer,
+});
+
+export const cloningActions = cloningSlice.actions;
+export default cloningSlice.reducer;

package/src/cloning_utils.js

@@ -0,0 +1,298 @@
+import { parseFeatureLocation } from '@teselagen/bio-parsers';
+import { flipContainedRange, getRangeLength } from '@teselagen/range-utils';
+
+export const isSequenceInputOfAnySource = (id, sources) => (sources.find((source) => source.input.some(({sequence}) => sequence === id))) !== undefined;
+
+export function getSourcesTakingSequenceAsInput(sources, sequenceId) {
+  return sources.filter((s) => s.input.some(({sequence}) => sequence === sequenceId));
+}
+
+export function isCompletePCRSource(source) {
+  return source.type === 'PCRSource' && source.input.length === 3 && source.input[0].type === 'AssemblyFragment';
+}
+
+export function isCompleteOligoHybridizationSource(source) {
+  return source.type === 'OligoHybridizationSource' && source.input.length === 2 && source.overhang_crick_3prime !== undefined && source.overhang_crick_3prime !== null;
+}
+
+export function getPcrTemplateSequenceId(source) {
+  return source.input.length === 1 ? source.input[0].sequence : source.input[1].sequence;
+}
+
+export function getIdsOfSequencesWithoutChildSource(sources, sequences) {
+  let idsSequencesWithChildSource = [];
+  sources.forEach((source) => {
+    idsSequencesWithChildSource = idsSequencesWithChildSource.concat(source.input.map(({sequence}) => sequence));
+  });
+  const sequencesNotChildSource = [];
+
+  sequences.forEach((sequence) => {
+    if (!idsSequencesWithChildSource.includes(sequence.id)) {
+      sequencesNotChildSource.push(sequence);
+    }
+  });
+  return sequencesNotChildSource.map((sequence) => sequence.id);
+}
+
+export function getInputSequencesFromSourceId(state, sourceId) {
+  const thisSource = state.cloning.sources.find((s) => s.id === sourceId);
+  // Sequences must be returned in the same order as in the source input, primers (undefined) are filtered out
+  return thisSource.input.map(({sequence}) => state.cloning.sequences.find((e) => e.id === sequence)).filter((e) => e !== undefined);
+}
+
+export function isSourceATemplate({ sources, sequences }, sourceId) {
+  // Get the output sequence
+  const source = sources.find((s) => s.id === sourceId);
+  const sequences2 = [...sequences.filter((e) => e.id === source.id), ...sequences.filter((e) => source.input.some((i) => i.sequence === e.id))];
+  return sequences2.some((s) => s.type === 'TemplateSequence');
+}
+
+export function getPrimerDesignObject({ sources, sequences }) {
+  // Find sequences that are templates and have primer_design set
+  const outputSequences = sequences.filter((e) => e.type === 'TemplateSequence' && Boolean(e.primer_design));
+  if (outputSequences.length === 0) {
+    // return 'No primer design sequence templates found';
+    return { finalSource: null, otherInputIds: [], pcrSources: [], outputSequences: [] };
+  }
+  const mockSequenceIds = outputSequences.map((s) => s.id);
+
+  // Find the PCRs from which the mock sequences are outputs
+  const pcrSources = sources.filter((s) => s.type === 'PCRSource' && mockSequenceIds.includes(s.id));
+  if (pcrSources.length === 0) {
+    return { finalSource: null, otherInputIds: [], pcrSources: [], outputSequences: [] };
+  }
+
+  // Find the template sequences for those PCRs
+  const templateSequences = sequences.filter((e) => pcrSources.some((ps) => ps.input.some((i) => i.sequence === e.id)));
+
+  // They should not be mock sequences
+  if (templateSequences.some((ts) => ts.type === 'TemplateSequence')) {
+    // return 'TemplateSequence input to final source is a TemplateSequence';
+    return { finalSource: null, otherInputIds: [], pcrSources: [], outputSequences: [] };
+  }
+
+  // Find the source they are input to (there should be zero or one)
+  const finalSources = sources.filter((s) => s.input.some((i) => mockSequenceIds.includes(i.sequence)));
+
+  if (finalSources.length === 0) {
+    // return as is
+    return { finalSource: null, otherInputIds: [], pcrSources, outputSequences };
+  }
+  if (finalSources.length > 1) {
+    // error
+    return { finalSource: null, otherInputIds: [], pcrSources: [], outputSequences: [] };
+  }
+
+  const finalSource = finalSources[0];
+
+  // Inputs to the finalSource that are not mock sequences with primer_design
+  const otherInputIds = finalSource.input.map((i) => i.sequence).filter((i) => !mockSequenceIds.includes(i));
+  const otherInputs = sequences.filter((e) => otherInputIds.includes(e.id));
+  // There should be no TemplateSequence as an input that does not have primer_design set
+  if (otherInputs.some((i) => i.type === 'TemplateSequence' && !Boolean(i.primer_design))) {
+    // return 'TemplateSequence input to final source does not have primer_design set';
+    return { finalSource: null, otherInputIds: [], pcrSources: [], outputSequences: [] };
+  }
+
+  return { finalSource, otherInputIds, pcrSources, outputSequences };
+}
+
+const formatPrimer = (primer, position) => {
+  const { name, sequence, id } = primer;
+  return {
+    id: `${id}`,
+    name,
+    ...position,
+    type: 'primer_bind',
+    primerBindsOn: '3prime',
+    forward: position.strand === 1,
+    bases: sequence,
+  };
+};
+
+export function pcrPrimerPositionsInInput(source, sequenceData) {
+  if (source.type !== 'PCRSource') {
+    throw new Error('Source is not a PCRSource');
+  }
+  const { size } = sequenceData;
+
+  const fwd = parseFeatureLocation(source.input[1].left_location, 0, 0, 0, 1, size)[0];
+  const rvs = parseFeatureLocation(source.input[1].right_location, 0, 0, 0, 1, size)[0];
+
+  if (!source.input[1].reverse_complemented) {
+    fwd.strand = 1;
+    rvs.strand = -1;
+    return [fwd, rvs];
+  }
+
+  const fwd2 = flipContainedRange(fwd, { start: 0, end: size - 1 }, size);
+  const rvs2 = flipContainedRange(rvs, { start: 0, end: size - 1 }, size);
+
+  fwd2.strand = -1;
+  rvs2.strand = 1;
+  return [fwd2, rvs2];
+}
+
+export function pcrPrimerPositionsInOutput(primers, sequenceData) {
+  const [fwdPrimer, rvsPrimer] = primers;
+  return [
+    { start: 0, end: fwdPrimer.sequence.length - 1, strand: 1 },
+    { start: sequenceData.size - rvsPrimer.sequence.length, end: sequenceData.size - 1, strand: -1 },
+  ];
+}
+
+export function getPCRPrimers({ primers, sources, teselaJsonCache }, sequenceId) {
+  let out = [];
+
+  // Get PCRs that have this sequence as input
+  const sourcesInput = getSourcesTakingSequenceAsInput(sources, sequenceId);
+  const sequenceData = teselaJsonCache[sequenceId];
+
+  sourcesInput.forEach((sourceInput) => {
+    if (isCompletePCRSource(sourceInput)) {
+      const pcrPrimers = [sourceInput.input[0].sequence, sourceInput.input[2].sequence].map((id) => primers.find((p) => p.id === id));
+      const primerPositions = pcrPrimerPositionsInInput(sourceInput, sequenceData);
+      out = out.concat(pcrPrimers.map((primer, i) => formatPrimer(primer, primerPositions[i])));
+    }
+  });
+
+  // Get the PCR that have this sequence as output (if any)
+  const sourceOutput = sources.find((s) => s.id === sequenceId);
+  if (sourceOutput?.type === 'PCRSource') {
+    const pcrPrimers = [sourceOutput.input[0].sequence, sourceOutput.input[2].sequence].map((id) => primers.find((p) => p.id === id));
+    const primerPositions = pcrPrimerPositionsInOutput(pcrPrimers, sequenceData);
+    out = out.concat(pcrPrimers.map((primer, i) => formatPrimer(primer, primerPositions[i])));
+  }
+  return out;
+}
+
+export function getNextUniqueId({ sources, sequences, primers }) {
+  const allIds = [...sources.map((s) => s.id), ...sequences.map((e) => e.id), ...primers.map((p) => p.id)];
+  if (allIds.length === 0) {
+    return 1;
+  }
+  return Math.max(...allIds) + 1;
+}
+
+export function shiftSource(source, idShift) {
+  const newSource = { ...source };
+  // Common part
+  newSource.id += idShift;
+  newSource.input = newSource.input.map((sourceInput) => ({ ...sourceInput, sequence: sourceInput.sequence + idShift }));
+  return newSource;
+}
+
+export function mergePrimersInSource(source, keepId, removeId) {
+  const newSource = { ...source };
+  if (isCompletePCRSource(newSource)) {
+    if (newSource.input[0].sequence === removeId) {
+      newSource.input[0].sequence = keepId;
+    }
+    if (newSource.input[2].sequence === removeId) {
+      newSource.input[2].sequence = keepId;
+    }
+  } else if (newSource.type === 'OligoHybridizationSource' || newSource.type === 'CRISPRSource') {
+    newSource.input = newSource.input.map((sourceInput) => {
+      if (sourceInput.type === 'SourceInput' && sourceInput.sequence === removeId) {
+        return { ...sourceInput, sequence: keepId };
+      }
+      return { ...sourceInput };
+    });
+  }
+
+  return newSource;
+}
+
+export function shiftStateIds(newState, oldState, skipPrimers = false) {
+  const { sources: newSources, sequences: newSequences, primers: newPrimers, files: newFiles } = newState;
+  const { sources: oldSources, sequences: oldSequences, primers: oldPrimers } = oldState;
+  let idShift = getNextUniqueId({ sources: oldSources, sequences: oldSequences, primers: oldPrimers });
+  // Substract the smallest id to minimize the starting id
+  idShift -= Math.min(...[...newSources.map((s) => s.id), ...newSequences.map((e) => e.id), ...newPrimers.map((p) => p.id)]);
+
+  return {
+    shiftedState: {
+      sequences: newSequences.map((e) => ({ ...e, id: e.id + idShift })),
+      primers: newPrimers.map((p) => ({ ...p, id: p.id + idShift })),
+      sources: newSources.map((s) => shiftSource(s, idShift)),
+      files: newFiles ? newFiles.map((f) => ({ ...f, sequence_id: f.sequence_id + idShift })) : [],
+    },
+    idShift, };
+}
+
+export function stringIsNotDNA(str) {
+  return str.match(/[^agct]/i) !== null;
+}
+
+export function formatGatewaySites(sites) {
+  const foundSites = [];
+  Object.keys(sites).forEach((siteName) => {
+    sites[siteName].forEach((location) => {
+      foundSites.push({ siteName, location });
+    });
+  });
+  return foundSites;
+}
+
+export function getSourceDatabaseId(sources, sequenceId) {
+  const source = sources.find((s) => s.id === sequenceId);
+  return source?.database_id;
+}
+
+export function primersInSource(source) {
+  if (isCompletePCRSource(source)) {
+    return [source.input[0].sequence, source.input[2].sequence];
+  }
+  if (source.type === 'OligoHybridizationSource' && source.input.length === 2) {
+    return source.input.map(({sequence}) => sequence);
+  }
+  if (source.type === 'CRISPRSource') {
+    return source.input.filter(({type}) => type === 'SourceInput').map(({sequence}) => sequence);
+  }
+  return [];
+}
+
+export function isAssemblyComplete(source) {
+  return source.input?.some(({type}) => type === 'AssemblyFragment');
+}
+
+export function getUsedPrimerIds(sources) {
+  return sources.flatMap((s) => primersInSource(s));
+}
+
+export function getSourcesWherePrimerIsUsed(sources, primerId) {
+  return sources.filter((s) => primersInSource(s).includes(primerId));
+}
+
+export function getPrimerBindingInfoFromSource(primers, source, sequenceLength) {
+  let fwdPrimer = null;
+  let rvsPrimer = null;
+  let fwdLength = 0;
+  let rvsLength = 0;
+
+  if (isCompletePCRSource(source)) {
+    fwdPrimer = primers.find((p) => p.id === source.input[0].sequence);
+    rvsPrimer = primers.find((p) => p.id === source.input[2].sequence);
+    const fwdLocation = parseFeatureLocation(source.input[0].right_location, 0, 0, 0, 1, sequenceLength)[0];
+    const rvsLocation = parseFeatureLocation(source.input[2].left_location, 0, 0, 0, 1, sequenceLength)[0];
+    fwdLength = getRangeLength(fwdLocation, sequenceLength);
+    rvsLength = getRangeLength(rvsLocation, sequenceLength);
+    if (fwdLength < 0) {
+      fwdLength += sequenceLength;
+    }
+    if (rvsLength < 0) {
+      rvsLength += sequenceLength;
+    }
+  } else if (isCompleteOligoHybridizationSource(source)) {
+    fwdPrimer = primers.find((p) => p.id === source.input[0].sequence);
+    rvsPrimer = primers.find((p) => p.id === source.input[1].sequence);
+    fwdLength = fwdPrimer.sequence.length + source.overhang_crick_3prime;
+    rvsLength = fwdLength;
+  }
+  return { sourceId: source.id, sourceType: source.type, fwdPrimer, rvsPrimer, fwdLength, rvsLength };
+}
+
+export function doesSourceHaveOutput(cloningState, sourceId) {
+  return Boolean(cloningState.sequences.find((s) => s.id === sourceId));
+}
+

package/src/cloning_utils.test.js

@@ -0,0 +1,66 @@
+import { it, describe } from 'vitest';
+import { pcrPrimerPositionsInInput } from './cloning_utils';
+
+// Template sequence fwd
+const source1 = {
+  type: 'PCRSource',
+  input: [
+    {
+      sequence: 1,
+      left_location: null,
+      right_location: '1..6',
+      reverse_complemented: false,
+    },
+    {
+      sequence: 2,
+      left_location: 'join(21..23,1..3)',
+      right_location: '10..15',
+      reverse_complemented: false,
+    },
+    {
+      sequence: 1,
+      left_location: '1..6',
+      right_location: null,
+      reverse_complemented: true,
+    },
+  ],
+};
+
+// Template sequence rvs
+const source2 = {
+  type: 'PCRSource',
+  input: [
+    {
+      sequence: 1,
+      left_location: null,
+      right_location: '1..7',
+      reverse_complemented: false,
+    },
+    {
+      sequence: 4,
+      left_location: 'join(21..23,1..4)',
+      right_location: '10..15',
+      reverse_complemented: true,
+    },
+    {
+      sequence: 2,
+      left_location: '1..6',
+      right_location: null,
+      reverse_complemented: true,
+    },
+  ],
+};
+
+describe('test pcrPrimerPositionsInInput', () => {
+  it('test normal case', () => {
+    const primerPos1 = pcrPrimerPositionsInInput(source1, { size: 23 });
+    expect(primerPos1).toEqual([{ start: 20, end: 2, strand: 1 }, { start: 9, end: 14, strand: -1 }]);
+
+    const primerPos2 = pcrPrimerPositionsInInput(source2, { size: 23 });
+    expect(primerPos2).toEqual([{ end: 2, start: 19, strand: -1 }, { end: 13, start: 8, strand: 1 }]);
+  });
+  it('raises error if source is not a PCRSource', () => {
+    const source = { type: 'dummy' };
+    expect(() => pcrPrimerPositionsInInput(source, { size: 23 })).toThrow('Source is not a PCRSource');
+  });
+});

package/src/index.js

@@ -0,0 +1,34 @@
+// optionally connect to the redux store
+import { createStore, combineReducers, applyMiddleware, compose } from 'redux';
+import { tg_modalState } from '@teselagen/ui';
+import {
+  vectorEditorReducer as VectorEditor,
+  vectorEditorMiddleware,
+} from '@teselagen/ove';
+import thunk from 'redux-thunk';
+import { reducer as form } from 'redux-form';
+import cloningReducer from './cloning';
+
+const composeEnhancer = (window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__
+    && window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__({
+      actionsBlacklist: ['HOVEREDANNOTATIONUPDATE', 'HOVEREDANNOTATIONCLEAR'],
+      // actionSanitizer,
+      latency: 1000,
+      name: 'openVE',
+    }))
+  || compose;
+
+const store = createStore(
+  combineReducers({
+    form,
+    tg_modalState,
+    VectorEditor: VectorEditor(),
+    cloning: cloningReducer,
+  }),
+  undefined,
+  composeEnhancer(
+    applyMiddleware(thunk, vectorEditorMiddleware), // your store should be redux-thunk connected for the VectorEditor component to work
+  ),
+);
+
+export default store;

package/vitest.config.js

@@ -0,0 +1,17 @@
+import { defineConfig } from 'vitest/config';
+import { resolve } from 'path';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'jsdom',
+    setupFiles: '../../tests/setup.js',
+    include: ['src/**/*.{test,spec}.{js,jsx}'],
+  },
+  resolve: {
+    alias: {
+      '@opencloning/store': resolve(__dirname, './src'),
+      '@opencloning/utils': resolve(__dirname, '../utils/src/utils'),
+    },
+  },
+});