@opencloning/utils 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,17 @@
+# @opencloning/utils
+
+## 1.0.0
+
+### Major Changes
+
+- babe2f9: Switch to monorepo structure and use changesets
+
+### Minor Changes
+
+- 8cd33bb: Rearrange dependencies
+
+### Patch Changes
+
+- Updated dependencies [8cd33bb]
+- Updated dependencies [babe2f9]
+  - @opencloning/store@1.0.0

package/package.json

@@ -0,0 +1,22 @@
+{
+    "name": "@opencloning/utils",
+    "version": "1.0.0",
+    "type": "module",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/manulera/OpenCloning_frontend.git",
+        "directory": "packages/utils"
+    },
+    "dependencies": {
+        "@opencloning/store": "workspace:*",
+        "@teselagen/bio-parsers": "^0.4.32",
+        "@teselagen/sequence-utils": "^0.3.35",
+        "@zip.js/zip.js": "^2.7.62",
+        "dom-to-svg": "^0.12.2",
+        "lodash-es": "^4.17.21"
+    },
+    "peerDependencies": {
+        "react": "^18.3.1",
+        "react-redux": "^8.1.3"
+    }
+}

package/src/config/urlWhitelist.js

@@ -0,0 +1,19 @@
+export default [
+  // GitHub repository for OpenCloning templates
+  'https://assets.opencloning.org/OpenCloning-submission',
+  // GitHub repository for annotated iGEM distribution
+  'https://assets.opencloning.org/annotated-igem-distribution',
+  // GitHub repository for SEVA plasmids index
+  'https://assets.opencloning.org/seva_plasmids_index',
+  // GitHub repository for SnapGene index
+  'https://assets.opencloning.org/SnapGene_crawler',
+  // GitHub repository for Open DNA Collections index
+  'https://assets.opencloning.org/open-dna-collections',
+  // NCBI entrez API
+  'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi',
+  'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi',
+  // Datasets api
+  'https://api.ncbi.nlm.nih.gov/datasets/v2alpha/taxonomy/taxon_suggest',
+  'https://api.ncbi.nlm.nih.gov/datasets/v2alpha/genome/taxon',
+  'https://api.ncbi.nlm.nih.gov/datasets/v2alpha/genome/accession',
+];

package/src/utils/ambiguous_dna_bases.json

@@ -0,0 +1,14 @@
+{
+    "M": "AC",
+    "R": "AG",
+    "W": "AT",
+    "S": "CG",
+    "Y": "CT",
+    "K": "GT",
+    "V": "ACG",
+    "H": "ACT",
+    "D": "AGT",
+    "B": "CGT",
+    "X": "GATC",
+    "N": "GATC"
+}

package/src/utils/enzyme_utils.js

@@ -0,0 +1,20 @@
+import { aliasedEnzymesByName, getReverseComplementSequenceString as reverseComplement } from '@teselagen/sequence-utils';
+import ambiguousDnaBases from './ambiguous_dna_bases.json';
+
+const enzymeArray = Object.values(aliasedEnzymesByName);
+
+export function getEnzymeRecognitionSequence(enzyme) {
+  if (!enzyme) {
+    return '';
+  }
+  const recognitionSeq = enzymeArray.find((e) => e.aliases.includes(enzyme))?.site;
+  if (!recognitionSeq) {
+    return '????';
+  }
+  return recognitionSeq.split('').map((base) => (base in ambiguousDnaBases ? ambiguousDnaBases[base] : base)).join('');
+}
+
+export function isEnzymePalyndromic(enzyme) {
+  const recognitionSeq = getEnzymeRecognitionSequence(enzyme);
+  return recognitionSeq === reverseComplement(recognitionSeq);
+}

package/src/utils/error2String.js

@@ -0,0 +1,18 @@
+export default function error2String(error) {
+  if (error.code === 'ERR_NETWORK') { return 'Cannot connect to backend server'; }
+  if (!error.code) {
+    return error.message;
+  }
+  const { detail } = error.response.data;
+  if (error.response.status === 500) return 'Internal server error';
+  if (typeof detail === 'string') {
+    return detail;
+  } if (typeof detail === 'object') {
+    const detail2 = detail.map((d) => {
+      const { input, ...rest } = d;
+      return rest;
+    });
+    return `Server error message:\n${JSON.stringify(detail2, null, 2)}`;
+  }
+  return '';
+}

package/src/utils/fileParsers.js

@@ -0,0 +1,69 @@
+import { stringIsNotDNA } from '@opencloning/store/cloning_utils';
+import { readSubmittedTextFile } from './readNwrite';
+
+export const primersFromTextFile = async (fileUploaded, existingNames) => {
+  const fileContent = await readSubmittedTextFile(fileUploaded);
+  const allLines = fileContent.split(/\r\n|\r|\n/);
+
+  let delimiter = null;
+  if (fileUploaded.name.endsWith('.csv')) {
+    delimiter = new RegExp('[,;]');
+  } else if (fileUploaded.name.endsWith('.tsv')) {
+    delimiter = /\t/;
+  } else {
+    throw new Error('File must be a .csv or .tsv file');
+  }
+  // Remove empty lines
+  const lines = allLines.filter(line => line.trim() !== '');
+
+  // If any line contains , and ;, throw an error
+  if (fileUploaded.name.endsWith('.csv') && fileContent.includes(',') && fileContent.includes(';')) {
+    throw new Error('File must contain only one delimiter, either comma or semicolon');
+  }
+
+  if (lines.length === 0) {
+    throw new Error('File is empty');
+  }
+
+  const headers = lines[0].split(delimiter);
+
+  const requiredHeaders = ['name', 'sequence'];
+  const missingHeaders = requiredHeaders.filter(
+    (header) => !headers.includes(header),
+  );
+
+  // The number of tabs on headers and all lines should be > 1 and the same
+  if (headers.length < 2) {
+    throw new Error('Headers should have at least 2 columns');
+  }
+
+  // All lines should have the same number of tabs
+  if (lines.some((line) => line.split(delimiter).length !== headers.length)) {
+    throw new Error('All lines should have the same number of columns');
+  }
+
+  // Required headers should be present
+  if (missingHeaders.length > 0) {
+    throw new Error(`Headers missing: ${missingHeaders.join(', ')}`);
+  }
+
+  const primersToAdd = lines.slice(1).map((line) => {
+    const values = line.split(delimiter);
+    const obj = { error: '' };
+    headers.forEach((header, i) => {
+      obj[header] = values[i];
+    });
+
+    if (existingNames.includes(obj.name)) {
+      obj.error = 'existing';
+    } else if (stringIsNotDNA(obj.sequence)) {
+      obj.error = 'invalid';
+      // TODO: Improvement: check for already existing sequences
+      // While this is not a problem, it removes data redundancy
+    }
+
+    return obj;
+  });
+
+  return primersToAdd;
+};

package/src/utils/getHttpClient.js

@@ -0,0 +1,20 @@
+import axios from 'axios';
+import urlWhitelist from '../config/urlWhitelist';
+
+export default function getHttpClient(extraUrls = []) {
+  const whitelist = [...urlWhitelist, import.meta.env.BASE_URL, window.location.origin, ...extraUrls];
+
+  const client = axios.create();
+
+  client.interceptors.request.use((config) => {
+    const url = new URL(config.url, config.baseURL || window.location.origin);
+
+    if (!whitelist.some((whitelistedUrl) => url.href.match(new RegExp(`^${whitelistedUrl}`)))) {
+      return Promise.reject(new Error(`Request blocked: URL not in whitelist ${url.href}`));
+    }
+
+    return config;
+  }, (error) => Promise.reject(error));
+
+  return client;
+}

package/src/utils/getStructuredBases.js

@@ -0,0 +1,109 @@
+import { clone } from 'lodash-es';
+import { getRangeLength, getSequenceWithinRange } from '@teselagen/range-utils';
+import { getComplementSequenceString, bioData } from '@teselagen/sequence-utils';
+
+const { ambiguous_dna_values } = bioData;
+export function getStructuredBases({
+  annotationRange,
+  forward,
+  bases = '',
+  start,
+  end,
+  fullSequence,
+  primerBindsOn,
+  sequenceLength,
+}) {
+  const annLen = getRangeLength({ start, end }, sequenceLength);
+  let basesToUse = bases;
+  if (bases.length < annLen) {
+    if (forward && primerBindsOn === '3prime') {
+      const toAddLen = annLen - bases.length;
+      for (let index = 0; index < toAddLen; index++) {
+        basesToUse = `&${basesToUse}`;
+      }
+    } else if (!forward && primerBindsOn === '5prime') {
+      const toAddLen = annLen - bases.length;
+      for (let index = 0; index < toAddLen; index++) {
+        basesToUse += '&';
+      }
+    }
+  }
+  const aRange = {
+    // tnr: this probably needs to be changed in case annotation wraps origin
+    start: annotationRange.start - start,
+    end: annotationRange.end - start,
+  };
+  const r = {
+    aRange,
+    basesNoInserts: basesToUse,
+    inserts: [],
+  };
+
+  const baseLen = basesToUse.length;
+  const diffLen = baseLen - annLen;
+  if (diffLen > 0) {
+    r.basesNoInserts = basesToUse.slice(
+      primerBindsOn === '5prime' ? 0 : diffLen,
+      primerBindsOn === '5prime' ? annLen : baseLen,
+    );
+    const insertBases = basesToUse.slice(
+      primerBindsOn === '5prime' ? annLen : 0,
+      primerBindsOn === '5prime' ? baseLen : diffLen,
+    );
+
+    r.inserts = [
+      {
+        bases: insertBases,
+        index: primerBindsOn === '5prime' ? annLen : 0,
+      },
+    ];
+  }
+  const basesForRange = getSequenceWithinRange(
+    aRange,
+    forward ? r.basesNoInserts : r.basesNoInserts.split('').reverse().join(''),
+  );
+  r.basesNoInsertsWithMetaData = basesForRange.split('').map((b, i) => {
+    const indexOfBase = i + annotationRange.start;
+    let seqForBase = (fullSequence && fullSequence[indexOfBase]) || '';
+    if (!forward) {
+      seqForBase = getComplementSequenceString(seqForBase);
+    }
+    const isMatch = seqForBase.toLowerCase() === b.toLowerCase();
+    const isAmbiguousMatch = !isMatch
+      && ambiguous_dna_values[b.toUpperCase()].length > 1
+      && ambiguous_dna_values[b.toUpperCase()].includes(seqForBase.toUpperCase());
+    return {
+      b,
+      isMatch,
+      isAmbiguousMatch,
+    };
+  });
+  r.allBasesWithMetaData = clone(r.basesNoInsertsWithMetaData);
+  if (!forward) {
+    r.allBasesWithMetaData = r.allBasesWithMetaData.reverse();
+  }
+  r.inserts
+    .sort((a, b) => a.index - b.index)
+    .forEach(({ bases, index }) => {
+      r.allBasesWithMetaData.splice(
+        index,
+        0,
+        ...bases.split('').map((b) => ({ b, isMatch: false })),
+      );
+    });
+
+  return r;
+}
+
+// const basesToUse = 'aaaaaaatcggtctcaa';
+//   const { allBasesWithMetaData } = getStructuredBases({
+//     annotationRange: { start: 0, end: 10 },
+//     forward: true,
+//     bases: basesToUse,
+//     start: 0 - 1,
+//     end: 10 - 1,
+//     fullSequence: 'tcggtctcaaacgcagttcga',
+//     primerBindsOn: '3prime',
+//     sequenceLength: 21,
+//   });
+//   console.log(allBasesWithMetaData);

package/src/utils/ncbiRequests.js

@@ -0,0 +1,102 @@
+import getHttpClient from './getHttpClient';
+
+const httpClient = getHttpClient();
+
+
+export async function taxonSuggest(userInput) {
+  const url = `https://api.ncbi.nlm.nih.gov/datasets/v2alpha/taxonomy/taxon_suggest/${userInput}`;
+  const params = {
+    taxon_resource_filter: 'TAXON_RESOURCE_FILTER_GENOME',
+    tax_rank_filter: 'higher_taxon',
+  };
+  const resp = await httpClient.get(url, { params });
+  const taxons = resp.data.sci_name_and_ids;
+
+  // This might change if the API endpoint changes
+  return taxons === undefined ? [] : taxons.filter((e) => e.rank === 'SPECIES');
+}
+
+export async function getReferenceAssemblyId(taxonId) {
+  const url = `https://api.ncbi.nlm.nih.gov/datasets/v2alpha/genome/taxon/${taxonId}/dataset_report?filters.reference_only=true`;
+  const resp = await httpClient.get(url);
+  const { reports } = resp.data;
+  return reports === undefined ? null : resp.data.reports[0].accession;
+}
+
+export async function geneSuggest(assemblyId, userInput) {
+  const url = `https://api.ncbi.nlm.nih.gov/datasets/v2alpha/genome/accession/${assemblyId}/annotation_report?search_text=${userInput}`;
+  const resp = await httpClient.get(url);
+  // TODO: add support for api key
+  // const resp = await httpClient.get(url, { params: {
+  //   api_key: 'blah',
+  // } });
+  const { reports } = resp.data;
+  return reports === undefined ? [] : reports;
+}
+
+export async function getInfoFromAssemblyId(assemblyId) {
+  const url = `https://api.ncbi.nlm.nih.gov/datasets/v2alpha/genome/accession/${assemblyId}/dataset_report?filters.assembly_version=all_assemblies`;
+  const resp = await httpClient.get(url);
+
+  if (resp.status === 404 || resp.data.reports === undefined) {
+    return null;
+  }
+  const { reports } = resp.data;
+  if (reports === undefined) {
+    return null;
+  }
+
+  const species = reports[0].organism;
+  const exactAssemblyMatch = reports.find((report) => report.accession === assemblyId);
+  let exactMatch = null;
+  let newerAssembly = null;
+  let pairedAccession = null;
+  if (!exactAssemblyMatch) {
+    // The assembly ID is valid, but it's not an exact match to a particular version.
+    // For example, passing GCA_000007565 will return entries, but the actual assembly versions
+    // are GCA_000007565.1, GCA_000007565.2
+    exactMatch = false;
+    newerAssembly = reports[0].current_accession;
+    pairedAccession = reports[0].paired_accession;
+  } else {
+    exactMatch = true;
+    newerAssembly = exactAssemblyMatch.assembly_info.assembly_status !== 'current' ? exactAssemblyMatch.current_accession : null;
+    pairedAccession = exactAssemblyMatch.paired_accession;
+  }
+
+  // const url2 = `https://api.ncbi.nlm.nih.gov/datasets/v2alpha/genome/accession/${assemblyId}/annotation_report/download_summary`;
+  // try {
+  //   const resp2 = await httpClient.get(url2);
+  //   const hasAnnotation = resp2.data.record_count !== undefined;
+  //   return { species, hasAnnotation, newerAssembly };
+  // } catch (error) {
+  //   return { species, hasAnnotation: false, newerAssembly };
+  // }
+  return { species, hasAnnotation: reports[0].annotation_info !== undefined, newerAssembly, exactMatch, pairedAccession };
+
+  // I used to check like this, but no longer works (see https://github.com/ncbi/datasets/issues/380)
+  // const annotationInfo = reports[0].annotation_info || null;
+  // return reports === undefined ? null : { species, annotationInfo };
+}
+
+export async function getInfoFromSequenceAccession(sequenceAccession) {
+  const url = `https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi?id=${sequenceAccession}&db=nuccore&retmode=json`;
+  // For example: https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi?id=CP046095.1&db=nuccore&retmode=json
+
+  const resp = await httpClient.get(url);
+  // I don't think this ever happens, but just in case
+  if (resp.status === 404 || resp.data.result.uids.length === 0) {
+    return null;
+  }
+
+  const { taxid: taxId, accessionversion: sequenceAccessionStandard } = resp.data.result[resp.data.result.uids[0]];
+
+  if (!taxId) {
+    return { species: null, sequenceAccessionStandard };
+  }
+
+  const url2 = `https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi?id=${taxId}&db=taxonomy&retmode=json`;
+  const resp2 = await httpClient.get(url2);
+  const { scientificname: organismName } = resp2.data.result[resp2.data.result.uids[0]];
+  return { species: { tax_id: taxId, organism_name: organismName }, sequenceAccessionStandard };
+}

package/src/utils/network.js

@@ -0,0 +1,184 @@
+import { cloneDeep } from 'lodash-es';
+import { getUsedPrimerIds, mergePrimersInSource, shiftStateIds, getSourcesTakingSequenceAsInput } from '@opencloning/store/cloning_utils';
+
+export function getParentNodes(node, sequences, sources) {
+  const parentSequences = sequences.filter((sequence) => node.source.input.includes(sequence.id));
+
+  return parentSequences.map((parentSequence) => {
+    const parentSource = sources.find((source) => source.id === parentSequence.id);
+    const parentNode = { source: parentSource, sequence: parentSequence };
+    return { ...parentNode, parentNodes: getParentNodes(parentNode, sequences, sources) };
+  });
+}
+
+export function substateHasFiles(cloningState, id) {
+  const source = cloningState.sources.find((s) => s.id === id);
+  const allParentIds = getAllParentSources(source, cloningState.sources).map((s) => s.id);
+  allParentIds.push(id);
+  return cloningState.files ? cloningState.files.some((f) => allParentIds.includes(f.sequence_id)) : false;
+};
+
+function getAllSourceIdsInParentNodes(node) {
+  const parentNodesSourceIds = node.parentNodes.map((parentNode) => parentNode.source.id);
+  return parentNodesSourceIds.concat(node.parentNodes.flatMap((parentNode) => getAllSourceIdsInParentNodes(parentNode)));
+}
+
+function parentNodeSorter(a, b) {
+  const aValue = getAllSourceIdsInParentNodes(a).concat(a.source.id);
+  const bValue = getAllSourceIdsInParentNodes(b).concat(b.source.id);
+  return Math.min(...aValue) - Math.min(...bValue);
+}
+
+export function getImmediateParentSources(sources, source) {
+  const parentIds = source.input.map(({sequence}) => sequence);
+  return sources.filter((s) => parentIds.includes(s.id));
+}
+
+export function getAllParentSources(source, sources, stopAtDatabaseId = false, parentSources = []) {
+  const thisParentSources = getImmediateParentSources(sources, source);
+  parentSources.push(...thisParentSources);
+  thisParentSources.forEach((parentSource) => {
+    if (stopAtDatabaseId && parentSource.database_id) {
+      return;
+    }
+    getAllParentSources(parentSource, sources, stopAtDatabaseId, parentSources);
+  });
+  return parentSources;
+}
+
+export function getSortedSourceIds(sources2sort, sources) {
+  const sortedSources = [...sources2sort];
+  sortedSources.sort((source1, source2) => {
+    // We also include the source itself for sorting, in case of grafting state
+    const parentSources1 = getAllParentSources(source1, sources);
+    const parentSources2 = getAllParentSources(source2, sources);
+    const parentSources1Ids = parentSources1.map((source) => source.id);
+    const parentSources2Ids = parentSources2.map((source) => source.id);
+    parentSources1Ids.push(source1.id);
+    parentSources2Ids.push(source2.id);
+    return Math.min(...parentSources1Ids) - Math.min(...parentSources2Ids);
+  });
+  return sortedSources.map((source) => source.id);
+}
+
+export const collectParentSequencesAndSources = (source, sources, sequences, stopAtDatabaseId = false) => {
+  const parentSources = getAllParentSources(source, sources, stopAtDatabaseId);
+  const parentSourceIds = parentSources.map((s) => s.id);
+  const parentSequences = sequences.filter((s) => parentSourceIds.includes(s.id));
+  return { parentSources, parentSequences };
+};
+
+export const getSubState = (state, id, stopAtDatabaseId = false) => {
+  const { sequences, sources, primers, appInfo, files } = state.cloning;
+  const sequencesToExport = sequences.filter((e) => e.id === id);
+  const sourcesToExport = sources.filter((s) => s.id === id);
+  if (sequencesToExport.length === 0) {
+    throw new Error(`Sequence with id ${id} not found`);
+  }
+  if (sourcesToExport.length === 0) {
+    throw new Error(`Source with id ${id} not found`);
+  }
+  const { parentSources, parentSequences } = collectParentSequencesAndSources(sourcesToExport[0], sources, sequences, stopAtDatabaseId);
+  sequencesToExport.push(...parentSequences);
+  sourcesToExport.push(...parentSources);
+
+  const primerIdsToExport = getUsedPrimerIds(sourcesToExport);
+  const primersToExport = primers.filter((p) => primerIdsToExport.includes(p.id));
+  const outputIds = sourcesToExport.map((s) => s.id);
+  const filesToExport = files ? files.filter((f) => outputIds.includes(f.sequence_id)) : [];
+  return { sequences: sequencesToExport, sources: sourcesToExport, primers: primersToExport, appInfo, files: filesToExport };
+};
+
+export const shiftState = (newState, oldState, skipPrimers = false) => {
+  if (newState.primers === undefined || newState.sequences === undefined || newState.sources === undefined) {
+    throw new Error('JSON file should contain at least keys: primers, sequences and sources');
+  }
+  if (newState.primers.length > 0 && skipPrimers) {
+    throw new Error('Primers cannot be loaded when skipping primers');
+  }
+
+  return shiftStateIds(newState, oldState, skipPrimers);
+};
+
+export function getGraftSequenceId({ sources, sequences }) {
+  const sequenceIdsThatAreInput = sources.reduce((result, source) => result.concat(source.input.map(({sequence}) => sequence)), []);
+  const allSequenceIds = sequences.map((seq) => seq.id);
+  const sequenceIdsThatAreNotInput = allSequenceIds.filter((sequenceId) => !sequenceIdsThatAreInput.includes(sequenceId));
+  const sourcesWithoutOutput = sources.filter((source) => !allSequenceIds.includes(source.id));
+  if (sourcesWithoutOutput.length === 0 && sequenceIdsThatAreNotInput.length === 1) {
+    return sequenceIdsThatAreNotInput[0];
+  }
+  return null;
+}
+
+export function mergePrimersInState(mergedState) {
+  const newState = cloneDeep(mergedState);
+  const removedPrimerIds = [];
+  for (let i = 0; i < newState.primers.length - 1; i++) {
+    const p1 = newState.primers[i];
+    for (let j = i + 1; j < newState.primers.length; j++) {
+      const p2 = newState.primers[j];
+      if (p1.name === p2.name) {
+        const sameDatabaseId = (!Boolean(p1.database_id) && !Boolean(p2.database_id)) || p1.database_id === p2.database_id;
+        if (p1.sequence === p2.sequence && sameDatabaseId) {
+          newState.sources = newState.sources.map((s) => mergePrimersInSource(s, p1.id, p2.id));
+          removedPrimerIds.push(p2.id);
+        } else {
+          throw new Error(`Primer name ${p1.name} exists in current session but has different sequence or database_id`);
+        }
+      }
+    }
+  }
+  newState.primers = newState.primers.filter((p) => !removedPrimerIds.includes(p.id));
+  return newState;
+}
+
+export function graftState(parentState, childState, graftSourceId) {
+  const { shiftedState: shiftedParentState, idShift } = shiftState(parentState, childState);
+
+  const graftSequenceId = getGraftSequenceId(shiftedParentState);
+  if (graftSequenceId === null) {
+    throw new Error('Invalid parent state');
+  }
+  const graftSequenceInParent = shiftedParentState.sequences.find((seq) => seq.id === graftSequenceId);
+
+  const parentGraftSource = shiftedParentState.sources.find((source) => source.id === graftSequenceId);
+  const childGraftSource = childState.sources.find((source) => source.id === graftSourceId);
+  const graftSequenceInChild = childState.sequences.find((seq) => seq.id === childGraftSource.id);
+  const mergedSource = { ...parentGraftSource, id: childGraftSource.id };
+
+  const parentSources = shiftedParentState.sources.filter((source) => source.id !== parentGraftSource.id);
+  const parentSequences = shiftedParentState.sequences.filter((seq) => seq.id !== graftSequenceId);
+  const childSources = childState.sources.filter((source) => source.id !== childGraftSource.id);
+
+  let childSequences = [...childState.sequences];
+  if (graftSequenceInChild && graftSequenceInChild.type === 'TemplateSequence') {
+    const updatedSequence = { ...graftSequenceInParent, id: graftSequenceInChild.id };
+    childSequences = childSequences.filter((seq) => seq.id !== graftSequenceInChild.id);
+    childSequences.push(updatedSequence);
+  }
+
+  let mergedState = {
+    sources: [...parentSources, ...childSources, mergedSource],
+    sequences: [...parentSequences, ...childSequences],
+    primers: [...shiftedParentState.primers, ...childState.primers],
+    files: [...shiftedParentState.files, ...childState.files],
+  };
+  mergedState = mergePrimersInState(mergedState);
+  return { mergedState, idShift };
+}
+
+export const mergeStates = (newState, oldState, skipPrimers = false) => {
+  const { shiftedState, idShift } = shiftState(newState, oldState, skipPrimers);
+  let mergedState = {
+    sources: [...oldState.sources, ...shiftedState.sources],
+    sequences: [...oldState.sequences, ...shiftedState.sequences],
+    primers: [...oldState.primers, ...shiftedState.primers],
+    files: [...oldState.files, ...shiftedState.files],
+    sourcesWithHiddenAncestors: oldState.sourcesWithHiddenAncestors,
+  };
+  if (!skipPrimers) {
+    mergedState = mergePrimersInState(mergedState);
+  }
+  return { mergedState, idShift };
+};