@opencloning/ui 1.2.0 → 1.3.1

package/src/components/assembler/graph_utils.test.js

@@ -0,0 +1,239 @@
+import { DirectedGraph } from 'graphology';
+import {
+  GRAPH_SPACER,
+  partsToGraph,
+  partsToEdgesGraph,
+  openCycleAtNode,
+  graphToMSA,
+  graphHasCycle
+} from './graph_utils';
+
+describe('GRAPH_SPACER', () => {
+  it('is the expected spacer string', () => {
+    expect(GRAPH_SPACER).toBe('---------');
+  });
+});
+
+describe('partsToGraph', () => {
+  it('creates nodes for each part', () => {
+    const parts = [
+      { left_overhang: 'A', right_overhang: 'B' },
+      { left_overhang: 'C', right_overhang: 'D' }
+    ];
+    const graph = partsToGraph(parts);
+    expect(graph.hasNode('A-B')).toBe(true);
+    expect(graph.hasNode('C-D')).toBe(true);
+  });
+
+  it('connects nodes that share an overhang', () => {
+    const parts = [
+      { left_overhang: 'A', right_overhang: 'B' },
+      { left_overhang: 'B', right_overhang: 'C' }
+    ];
+    const graph = partsToGraph(parts);
+    expect(graph.hasEdge('A-B', 'B-C')).toBe(true);
+  });
+
+  it('does not connect nodes that do not share an overhang', () => {
+    const parts = [
+      { left_overhang: 'A', right_overhang: 'B' },
+      { left_overhang: 'C', right_overhang: 'D' }
+    ];
+    const graph = partsToGraph(parts);
+    expect(graph.hasEdge('A-B', 'C-D')).toBe(false);
+  });
+
+  it('handles duplicate parts', () => {
+    const parts = [
+      { left_overhang: 'A', right_overhang: 'B' },
+      { left_overhang: 'A', right_overhang: 'B' }
+    ];
+    const graph = partsToGraph(parts);
+    expect(graph.nodes().length).toBe(1);
+    expect(graph.hasNode('A-B')).toBe(true);
+  });
+
+  it('handles empty parts array', () => {
+    const graph = partsToGraph([]);
+    expect(graph.nodes().length).toBe(0);
+  });
+
+  it('creates a chain of connected nodes', () => {
+    const parts = [
+      { left_overhang: 'A', right_overhang: 'B' },
+      { left_overhang: 'B', right_overhang: 'C' },
+      { left_overhang: 'C', right_overhang: 'D' }
+    ];
+    const graph = partsToGraph(parts);
+    expect(graph.hasEdge('A-B', 'B-C')).toBe(true);
+    expect(graph.hasEdge('B-C', 'C-D')).toBe(true);
+  });
+});
+
+describe('partsToEdgesGraph', () => {
+  it('creates nodes for each unique overhang and creates edges between them', () => {
+    const parts = [
+      { left_overhang: 'A', right_overhang: 'B' },
+      { left_overhang: 'C', right_overhang: 'D' }
+    ];
+    const graph = partsToEdgesGraph(parts);
+    expect(graph.hasNode('A')).toBe(true);
+    expect(graph.hasNode('B')).toBe(true);
+    expect(graph.hasNode('C')).toBe(true);
+    expect(graph.hasNode('D')).toBe(true);
+    expect(graph.hasEdge('A', 'B')).toBe(true);
+    expect(graph.hasEdge('C', 'D')).toBe(true);
+  });
+
+  it('handles duplicate overhangs', () => {
+    const parts = [
+      { left_overhang: 'A', right_overhang: 'B' },
+      { left_overhang: 'A', right_overhang: 'B' }
+    ];
+    const graph = partsToEdgesGraph(parts);
+    expect(graph.hasNode('A')).toBe(true);
+    expect(graph.hasNode('B')).toBe(true);
+    expect(graph.hasEdge('A', 'B')).toBe(true);
+    expect(graph.nodes().length).toBe(2);
+  });
+
+  it('handles empty parts array', () => {
+    const graph = partsToEdgesGraph([]);
+    expect(graph.nodes().length).toBe(0);
+  });
+});
+
+describe('openCycleAtNode', () => {
+  it('removes incoming edges to the specified node and does not affect outgoing edges', () => {
+    const graph = new DirectedGraph();
+    graph.addNode('A');
+    graph.addNode('B');
+    graph.addNode('C');
+    graph.addEdge('A', 'B');
+    graph.addEdge('B', 'C');
+    graph.addEdge('C', 'B'); // Creates cycle
+    
+    expect(graph.inDegree('B')).toBe(2);
+    openCycleAtNode(graph, 'B');
+    expect(graph.inDegree('B')).toBe(0);
+    expect(graph.outDegree('B')).toBe(1);
+
+  });
+
+  it('does not affect outgoing edges', () => {
+    const graph = new DirectedGraph();
+    graph.addNode('A');
+    graph.addNode('B');
+    graph.addEdge('A', 'B');
+    graph.addEdge('B', 'A'); // Cycle
+    
+    openCycleAtNode(graph, 'A');
+    expect(graph.outDegree('A')).toBe(1);
+    expect(graph.hasEdge('A', 'B')).toBe(true);
+  });
+
+  it('handles node with no incoming edges', () => {
+    const graph = new DirectedGraph();
+    graph.addNode('A');
+    graph.addNode('B');
+    graph.addEdge('A', 'B');
+    
+    openCycleAtNode(graph, 'A');
+    expect(graph.inDegree('A')).toBe(0);
+    expect(graph.hasEdge('A', 'B')).toBe(true);
+  });
+});
+
+describe('graphToMSA', () => {
+  it('converts a simple linear DAG to MSA', () => {
+    const graph = new DirectedGraph();
+    graph.addNode('A');
+    graph.addNode('B');
+    graph.addNode('C');
+    graph.addEdge('A', 'B');
+    graph.addEdge('B', 'C');
+    graph.addEdge('C', 'A');
+    const msa = graphToMSA(graph);
+    expect(msa.length).toBe(1);
+    expect(msa[0]).toContain('A');
+    expect(msa[0]).toContain('B');
+    expect(msa[0]).toContain('C');
+  });
+
+  it('handles branching paths', () => {
+    const graph = new DirectedGraph();
+    graph.addNode('A');
+    graph.addNode('B1');
+    graph.addNode('B2');
+    graph.addNode('B3');
+    graph.addNode('C');
+    graph.addEdge('A', 'B1');
+    graph.addEdge('A', 'B2');
+    graph.addEdge('B1', 'C');
+    graph.addEdge('B2', 'B3');
+    graph.addEdge('B3', 'C');
+    graph.addEdge('C', 'A');
+    const msa = graphToMSA(graph);
+    expect(msa).toEqual([
+      ['A', 'B2', 'B3', 'C'],
+      ['A', 'B1', GRAPH_SPACER, 'C'],
+    ]);
+  });
+
+  it('handles empty graph', () => {
+    const graph = new DirectedGraph();
+    const msa = graphToMSA(graph);
+    expect(msa).toEqual([]);
+  });
+
+  it('handles single node', () => {
+    const graph = new DirectedGraph();
+    graph.addNode('A');
+    const msa = graphToMSA(graph);
+    expect(msa).toEqual([]);
+  });
+});
+
+
+describe('graphHasCycle', () => {
+  it('returns false for acyclic graph', () => {
+    const graph = new DirectedGraph();
+    graph.addNode('A');
+    graph.addNode('B');
+    graph.addNode('C');
+    graph.addEdge('A', 'B');
+    graph.addEdge('B', 'C');
+    
+    expect(graphHasCycle(graph)).toBe(false);
+  });
+
+  it('returns true for cyclic graph', () => {
+    const graph = new DirectedGraph();
+    graph.addNode('A');
+    graph.addNode('B');
+    graph.addEdge('A', 'B');
+    graph.addEdge('B', 'A');
+    
+    expect(graphHasCycle(graph)).toBe(true);
+  });
+
+  it('handles self-loop', () => {
+    const graph = new DirectedGraph();
+    graph.addNode('A');
+    graph.addEdge('A', 'A');
+    
+    expect(graphHasCycle(graph)).toBe(true);
+  });
+
+  it('handles empty graph', () => {
+    const graph = new DirectedGraph();
+    expect(graphHasCycle(graph)).toBe(false);
+  });
+
+  it('handles single node with no edges', () => {
+    const graph = new DirectedGraph();
+    graph.addNode('A');
+    
+    expect(graphHasCycle(graph)).toBe(false);
+  });
+});

package/src/components/assembler/index.js

@@ -0,0 +1,9 @@
+export { default as AssemblerPart } from './AssemblerPart';
+export { AssemblerPartCore } from './AssemblerPart';
+export { getSvgByGlyph } from './sbol_visual_glyphs';
+export { DisplayOverhang, DisplayInside, AssemblerPartContainer } from './AssemblerPart';
+export { partDataToDisplayData } from './assembler_utils.js';
+export { partsToGraph, graphToMSA, graphHasCycle, partsToEdgesGraph, GRAPH_SPACER } from './graph_utils.js';
+export { usePlasmidsLogic } from './usePlasmidsLogic.js';
+export { default as PlasmidSyntaxTable } from './PlasmidSyntaxTable.jsx';
+export { default as ExistingSyntaxDialog } from './ExistingSyntaxDialog.jsx';

package/src/components/assembler/useAssembler.js

@@ -2,9 +2,31 @@ import { useCallback } from 'react'
 import { classNameToEndPointMap } from '@opencloning/utils/sourceFunctions'
 import useBackendRoute from '../../hooks/useBackendRoute'
 import useHttpClient from '../../hooks/useHttpClient'
-import { arrayCombinations } from '../eLabFTW/utils'
+import { arrayCombinations } from './assembler_utils'
 
 
+function formatLoadedFile(plasmid, id) {
+  return {
+    source: {
+      id,
+      type: 'UploadedFileSource',
+      input: [],
+      sequence_file_format: "genbank",
+      file_name: plasmid.file_name,
+      index_in_file: 0,
+    },
+    sequence: {
+      id,
+      type: 'TextFileSequence',
+      sequence_file_format: "genbank",
+      overhang_crick_3prime: 0,
+      overhang_watson_3prime: 0,
+      file_content: plasmid.genbankString,
+    },
+    plasmid: plasmid,
+  }
+}
+
 export const useAssembler = () => {
   const httpClient = useHttpClient();
   const backendRoute = useBackendRoute();
@@ -12,25 +34,35 @@ export const useAssembler = () => {
   const requestSources = useCallback(async (assemblerOutput) => {
     const processedOutput = []
     for (let pos = 0; pos < assemblerOutput.length; pos++) {
-        processedOutput.push([])
-        for (let source of assemblerOutput[pos]) {
+      processedOutput.push([])
+      for (let plasmid of assemblerOutput[pos]) {
+        try {
+          if (plasmid.type === 'loadedFile') {
+            processedOutput[pos].push(formatLoadedFile(plasmid, pos + 1))
+          } else {
+            const { source } = plasmid;
             const url = backendRoute(classNameToEndPointMap[source.type])
             const {data} = await httpClient.post(url, source)
             if (data.sources.length !== 1) {
-                console.error('Expected 1 source, got ' + data.sources.length)
+              console.error('Expected 1 source, got ' + data.sources.length)
             }
             const thisData = {
-                source: {...data.sources[0], id: pos + 1},
-                sequence: {...data.sequences[0], id: pos + 1},
+              source: {...data.sources[0], id: pos + 1},
+              sequence: {...data.sequences[0], id: pos + 1},
+              plasmid: plasmid,
             }
             processedOutput[pos].push(thisData)
+          }} catch (e) {
+          e.plasmid = plasmid;
+          throw e;
         }
+      }
     }
     return processedOutput
-  }, [])
+  }, [ httpClient, backendRoute ])
 
 
-  const requestAssemblies = useCallback(async (requestedSources) => {
+  const requestAssemblies = useCallback(async (requestedSources, enzyme='BsaI') => {
 
     const assemblies = arrayCombinations(requestedSources);
     const output = []
@@ -43,28 +75,33 @@ export const useAssembler = () => {
       }
       const requestData = {
         source: {
-            type: 'RestrictionAndLigationSource',
-            restriction_enzymes: ['BsaI'],
-            id: assembly.length + 1,
+          type: 'RestrictionAndLigationSource',
+          restriction_enzymes: [enzyme],
+          id: assembly.length + 1,
         },
         sequences: assembly.map((p) => p.sequence),
       }
-      const {data} = await httpClient.post(url, requestData, config)
-      const thisSource = data.sources[0]
-      const thisSequence = data.sequences[0]
-      thisSource.id = assembly.length + 1
-      thisSequence.id = assembly.length + 1
+      try {
+        const {data} = await httpClient.post(url, requestData, config)
+        const thisSource = data.sources[0]
+        const thisSequence = data.sequences[0]
+        thisSource.id = assembly.length + 1
+        thisSequence.id = assembly.length + 1
 
 
-      const cloningStrategy = {
-        sources: [thisSource, ...assembly.map((p) => p.source)],
-        sequences: [thisSequence, ...assembly.map((p) => p.sequence)],
-        primers: [],
+        const cloningStrategy = {
+          sources: [thisSource, ...assembly.map((p) => p.source)],
+          sequences: [thisSequence, ...assembly.map((p) => p.sequence)],
+          primers: [],
+        }
+        output.push(cloningStrategy)
+      } catch (e) {
+        e.assembly = assembly;
+        throw e;
       }
-      output.push(cloningStrategy)
     }
     return output;
-  }, [])
+  }, [ httpClient, backendRoute ])
 
   return { requestSources, requestAssemblies }
 }

package/src/components/assembler/useCombinatorialAssembly.js

@@ -0,0 +1,76 @@
+import React from 'react'
+import { arrayCombinations, categoryFilter } from './assembler_utils'
+
+function isAssemblyComplete(assembly, categories) {
+  const lastPosition = assembly.length - 1
+  if (lastPosition === -1) {
+    return false
+  }
+  const lastCategory = categories.find((category) => category.id === assembly[lastPosition].category)
+  return lastCategory?.right_overhang === categories[0].left_overhang
+}
+
+
+export default function useCombinatorialAssembly( { onValueChange, categories, plasmids }) {
+
+  const [assembly, setAssembly] = React.useState([])
+
+  const setCategory = React.useCallback((category, index) => {
+    onValueChange()
+    if (category === '') {
+      setAssembly(prev => prev.slice(0, index))
+    } else {
+      setAssembly(prev => [...prev.slice(0, index), { category, plasmidIds: [] }])
+    }
+  }, [onValueChange])
+
+  const setId = React.useCallback((plasmidIds, index) => {
+    onValueChange()
+    // Handle case where user clears all selections (empty array)
+    const value = (!plasmidIds || plasmidIds.length === 0) ? [] : plasmidIds
+    setAssembly( prev => prev.map((item, i) => i === index ? { ...item, plasmidIds: value } : item))
+  }, [onValueChange])
+
+  // If the next category of the assembly can only be one, add it to the assembly
+  React.useEffect(() => {
+    const newAssembly = [...assembly]
+    while (true) {
+      if (isAssemblyComplete(newAssembly, categories)) {
+        break
+      }
+      let lastPosition = newAssembly.length - 1
+      const previousCategoryId = lastPosition === -1 ? null : newAssembly[lastPosition].category
+      let nextCategories = categories.filter((category) => categoryFilter(category, categories, previousCategoryId))
+      if (nextCategories.length !== 1) {
+        break
+      } else if (nextCategories.length === 1) {
+        newAssembly.push({ category: nextCategories[0].id, plasmidIds: [] })
+      }
+    }
+    if (newAssembly.length !== assembly.length) {
+      setAssembly(newAssembly)
+    }
+  }, [assembly, categories])
+
+  // If plasmids are removed, remove them from the assembly
+  React.useEffect(() => {
+    onValueChange()
+    setAssembly(prev => {
+      const existingPlasmidIds = plasmids.map((plasmid) => plasmid.id)
+      return prev.map((item) => ({ ...item, plasmidIds: item.plasmidIds.filter((id) => existingPlasmidIds.includes(id)) }))
+    }
+    )
+  }, [plasmids, onValueChange])
+
+  // If categories are changed, clear the assembly
+  React.useEffect(() => {
+    setAssembly([])
+  }, [categories])
+
+  const expandedAssemblies = React.useMemo(() => arrayCombinations(assembly.map(({ plasmidIds }) => plasmidIds)), [assembly])
+  const assemblyComplete = isAssemblyComplete(assembly, categories);
+  const canBeSubmitted = assemblyComplete && assembly.every((item) => item.plasmidIds.length > 0)
+  const currentCategories = React.useMemo(() => assembly.map((item) => item.category), [assembly])
+
+  return React.useMemo(() => ({ assembly, setCategory, setId, expandedAssemblies, assemblyComplete, canBeSubmitted, currentCategories }), [assembly, setCategory, setId, expandedAssemblies, assemblyComplete, canBeSubmitted, currentCategories])
+}

package/src/components/assembler/usePlasmidsLogic.js

@@ -0,0 +1,82 @@
+import React from 'react';
+import { anyToJson } from '@teselagen/bio-parsers';
+import { partsToEdgesGraph } from '@opencloning/ui/components/assembler';
+import { assignSequenceToSyntaxPart } from './assembler_utils';
+import { aliasedEnzymesByName } from '@teselagen/sequence-utils';
+
+/**
+ * Custom hook that manages plasmids state and logic
+ * @param {Object} params - Dependencies from FormDataContext
+ * @param {Array} params.parts - Array of parts
+ * @param {string} params.assemblyEnzyme - Assembly enzyme name
+ * @param {Object} params.overhangNames - Mapping of overhangs to names
+ * @returns {Object} - { linkedPlasmids, setLinkedPlasmids, uploadPlasmids }
+ */
+export function usePlasmidsLogic({ parts, assemblyEnzyme, overhangNames }) {
+  const [linkedPlasmids, setLinkedPlasmidsState] = React.useState([]);
+
+  const graphForPlasmids = React.useMemo(() => partsToEdgesGraph(parts), [parts]);
+  const partDictionary = React.useMemo(() => parts.reduce((acc, part) => {
+    acc[`${part.left_overhang}-${part.right_overhang}`] = part;
+    return acc;
+  }, {}), [parts]);
+
+  const assignPlasmids = React.useCallback((plasmids) => plasmids.map(plasmid => {
+    const enzymes = [aliasedEnzymesByName[assemblyEnzyme.toLowerCase()]];
+    const correspondingParts = assignSequenceToSyntaxPart(plasmid, enzymes, graphForPlasmids);
+    const correspondingPartsStr = correspondingParts.map(part => `${part.left_overhang}-${part.right_overhang}`);
+    const correspondingPartsNames = correspondingParts.map(part => {
+      let namePart = '';
+      const leftName = overhangNames[part.left_overhang];
+      const rightName = overhangNames[part.right_overhang];
+      if (leftName || rightName) {
+        namePart = `${leftName || part.left_overhang}-${rightName || part.right_overhang}`;
+      }
+      return namePart;
+    });
+    return {
+      ...plasmid,
+      appData: {
+        ...plasmid.appData,
+        correspondingParts: correspondingPartsStr,
+        partInfo: correspondingPartsStr.map(partStr => partDictionary[partStr]),
+        correspondingPartsNames: correspondingPartsNames,
+        longestFeature: correspondingParts.map(part => part.longestFeature)
+      }
+    };
+  }), [graphForPlasmids, partDictionary, assemblyEnzyme, overhangNames]);
+
+  // Wrapper for setLinkedPlasmids that automatically assigns plasmids if enzyme is available
+  const setLinkedPlasmids = React.useCallback((plasmids) => {
+    if (assemblyEnzyme && Array.isArray(plasmids) && plasmids.length > 0) {
+      setLinkedPlasmidsState(assignPlasmids(plasmids));
+    } else {
+      setLinkedPlasmidsState(plasmids);
+    }
+  }, [assemblyEnzyme, assignPlasmids]);
+
+  // Update existing plasmids when enzyme or assignment logic changes
+  React.useEffect(() => {
+    if (assemblyEnzyme) {
+      setLinkedPlasmidsState((prevLinkedPlasmids) => {
+        if (prevLinkedPlasmids.length > 0) {
+          return assignPlasmids(prevLinkedPlasmids);
+        }
+        return prevLinkedPlasmids;
+      });
+    }
+  }, [assignPlasmids, assemblyEnzyme]); // Note: intentionally not including linkedPlasmids to avoid infinite loop
+
+  const uploadPlasmids = React.useCallback(async (files) => {
+    const plasmids = await Promise.all(files.map(async (file) => {
+      const data = await anyToJson(file);
+      const sequenceData = data[0].parsedSequence;
+      // Force circular
+      sequenceData.circular = true;
+      return {...sequenceData, appData: { fileName: file.name, correspondingParts: [], partInfo: [], correspondingPartsNames: [] } };
+    }));
+    setLinkedPlasmids(plasmids);
+  }, [setLinkedPlasmids]);
+
+  return { linkedPlasmids, setLinkedPlasmids, uploadPlasmids };
+}

package/src/components/eLabFTW/utils.js

@@ -28,12 +28,3 @@ export const getFileFromELabFTW = async (itemId, fileInfo) => {
     throw new Error(`${error2String(e)}`);
   }
 };
-
-export function arrayCombinations(sets) {
-  if (sets.length === 1) {
-    return sets[0].map((el) => [el]);
-  } else
-    return sets[0].flatMap((val) =>
-      arrayCombinations(sets.slice(1)).map((c) => [val].concat(c))
-    );
-};

package/src/components/index.js

@@ -1,2 +1,4 @@
 export { default as OpenCloning } from './OpenCloning';
 export { default as MainAppBar } from './navigation/MainAppBar';
+export { default as useUrlParamsLoader } from '../hooks/useUrlParamsLoader';
+export { default as useInitializeApp } from '../hooks/useInitializeApp';

package/src/components/navigation/SelectTemplateDialog.jsx

@@ -11,7 +11,6 @@ function SelectTemplateDialog({ onClose, open }) {
   const baseUrl = 'https://assets.opencloning.org/OpenCloning-submission';
   const httpClient = useHttpClient();
 
-  // const baseUrl = '';
   React.useEffect(() => {
     const fetchData = async () => {
       try {

package/src/components/primers/DownloadPrimersButton.jsx

@@ -85,7 +85,6 @@ function DownloadPrimersButton({ primers }) {
   return (
     <>
       <Button
-        variant="contained"
         onClick={() => setDialogOpen(true)}
       >
         Download Primers

package/src/components/primers/PrimerList.jsx

@@ -1,6 +1,6 @@
 import React from 'react';
 import { shallowEqual, useDispatch, useSelector } from 'react-redux';
-import { Button } from '@mui/material';
+import { Button, ButtonGroup } from '@mui/material';
 import PrimerForm from './PrimerForm';
 import PrimerTableRow from './PrimerTableRow';
 import './PrimerList.css';
@@ -99,8 +99,8 @@ function PrimerList() {
           />
         )) || (
             <div className="primer-add-container">
+              <ButtonGroup>
               <Button
-                variant="contained"
                 onClick={switchAddingPrimer}
               >
                 Add Primer
@@ -109,12 +109,13 @@ function PrimerList() {
               <DownloadPrimersButton primers={primers} />
               {database && (
                 <Button
-                  variant="contained"
                   onClick={() => setImportingPrimer(true)}
                 >
                   {`Import from ${database.name}`}
                 </Button>
+                
               )}
+              </ButtonGroup>
             </div>
           )}
       </div>

package/src/components/primers/import_primers/ImportPrimersButton.jsx

@@ -52,7 +52,6 @@ function ImportPrimersButton({ addPrimer }) {
       <Tooltip arrow title={<span style={{ fontSize: '1.4em' }}>Upload a .csv or .tsv file with headers &apos;name&apos; and &apos;sequence&apos;</span>}>
         <Button
           onClick={handleUploadClick}
-          variant="contained"
         >
           Import from file
         </Button>

package/src/version.js

@@ -1,2 +1,2 @@
 // Version placeholder - replaced at publish time via prepack script
-export const version = "1.2.0";
+export const version = "1.3.1";

package/vitest.config.js

@@ -1,12 +1,10 @@
 import { defineConfig } from 'vitest/config';
 import { resolve } from 'path';
+import { testConfig } from '../../vitest.common.config';
 
 export default defineConfig({
   test: {
-    globals: true,
-    environment: 'jsdom',
-    setupFiles: '../../tests/setup.js',
-    include: ['src/**/*.{test,spec}.{js,jsx}'],
+    ...testConfig,
   },
   resolve: {
     alias: {

package/src/components/DraggableDialogPaper.jsx

@@ -1,16 +0,0 @@
-import { Paper } from '@mui/material';
-import React from 'react';
-import Draggable from 'react-draggable';
-
-function DraggableDialogPaper(props) {
-  return (
-    <Draggable
-      handle="#draggable-dialog-title"
-      cancel={'[class*="MuiDialogContent-root"]'}
-    >
-      <Paper {...props} />
-    </Draggable>
-  );
-}
-
-export default DraggableDialogPaper;