exports and imports OK

Author: MaxNumerique

composables/project_manager.js

@@ -37,23 +37,19 @@ export function useProjectManager() {
 
       const infra = useInfraStore()
       await infra.create_connection()
+      const schemaImport = back_schemas.opengeodeweb_back.import_project || {}
 
       const form = new FormData()
-      form.append("file", file, file.name || "project.zip")
+      form.append("file", file, file?.name || "project.zip")
 
-      const importPath =
-        back_schemas.opengeodeweb_back.import_project?.$id ||
-        "opengeodeweb_back/import_project"
-
-      const result = await $fetch(importPath, {
+      const result = await $fetch(schemaImport.$id, {
         baseURL: geode.base_url,
         method: "POST",
         body: form,
       })
-      console.log(
-        "[ProjectManager] snapshot keys:",
-        Object.keys(result?.snapshot || {}),
-      )
+
+      const snapshot = result?.snapshot ?? {}
+      console.log("[ProjectManager] snapshot keys:", Object.keys(snapshot || {}))
 
       await viewer_call({
         schema: viewer_schemas.opengeodeweb_viewer.import_project,
@@ -68,13 +64,14 @@ export function useProjectManager() {
       treeviewStore.isImporting = true
       console.log("[ProjectManager] isImporting = true")
 
-      await appStore.importStores(result.snapshot)
+      await appStore.importStores(snapshot)
       console.log("[ProjectManager] stores imported")
 
       const dataStyleStore = useDataStyleStore()
       await dataStyleStore.applyAllStylesFromState()
       console.log("[ProjectManager] styles applied")
 
+      treeviewStore.finalizeImportSelection()
       treeviewStore.isImporting = false
       console.log("[ProjectManager] isImporting = false")
     } finally {

stores/data_base.js

@@ -47,6 +47,9 @@ export const useDataBaseStore = defineStore("dataBase", () => {
       params: { id },
     })
   }
+  
+  const treeviewStore = useTreeviewStore()
+  const hybridViewerStore = useHybridViewerStore()
 
   async function addItem(
     id,
@@ -71,7 +74,7 @@ export const useDataBaseStore = defineStore("dataBase", () => {
       await fetchUuidToFlatIndexDict(id)
     }
 
-    treeview_store.addItem(
+    treeviewStore.addItem(
       value.geode_object,
       value.displayed_name,
       id,
@@ -80,8 +83,7 @@ export const useDataBaseStore = defineStore("dataBase", () => {
     console.log("[DataBase] addItem -> treeview.addItem done", id)
 
     console.log("[DataBase] addItem -> hybridViewer.addItem start", id)
-    // Ajout viewer (potentiellement asynchrone)
-    await hybridViewerStore.addItem(id, value.vtk_js)
+    await hybridViewerStore.addItem(id)
     console.log("[DataBase] addItem -> hybridViewer.addItem done", id)
   }
 
@@ -116,13 +118,29 @@ export const useDataBaseStore = defineStore("dataBase", () => {
     )
   }
 
+  function exportStores() {
+    const snapshotDb = {}
+    for (const [id, item] of Object.entries(db)) {
+      if (!item) continue
+      snapshotDb[id] = {
+        object_type: item.object_type,
+        geode_object: item.geode_object,
+        native_filename: item.native_filename,
+        viewable_filename: item.viewable_filename,
+        displayed_name: item.displayed_name,
+        vtk_js: {
+          binary_light_viewable: item?.vtk_js?.binary_light_viewable,
+        },
+      }
+    }
+    return { db: snapshotDb }
+  }
+
   async function importStores(snapshot) {
-    const entries = snapshot?.db || {}
-    const hybrid_store = useHybridViewerStore()
-    await hybrid_store.initHybridViewer()
-    hybrid_store.clear()
-    console.log("[DataBase] importStores entries:", Object.keys(entries))
-    for (const [id, item] of Object.entries(entries)) {
+    await hybridViewerStore.initHybridViewer()
+    hybridViewerStore.clear()
+    console.log("[DataBase] importStores entries:", Object.keys(snapshot?.db || {}))
+    for (const [id, item] of Object.entries(snapshot?.db || {})) {
       await registerObject(id)
       await addItem(id, item)
     }
@@ -169,7 +187,7 @@ export const useDataBaseStore = defineStore("dataBase", () => {
     getSurfacesUuids,
     getBlocksUuids,
     getFlatIndexes,
-    exportStores,
+    exportStores,   // maintenant défini
     importStores,
   }
 })

stores/data_style.js

@@ -15,11 +15,12 @@ export const useDataStyleStore = defineStore("dataStyle", () => {
   }
 
   function setVisibility(id, visibility) {
-    console.log(
-      "dataBaseStore.itemMetaDatas(id)",
-      dataBaseStore.itemMetaDatas(id),
-    )
-    const object_type = dataBaseStore.itemMetaDatas(id).object_type
+    const meta = dataBaseStore.itemMetaDatas(id)
+    if (!meta) {
+      console.warn("[DataStyle] setVisibility skipped: unknown id", id)
+      return Promise.resolve([])
+    }
+    const object_type = meta.object_type
     if (object_type === "mesh") {
       return Promise.all([meshStyleStore.setMeshVisibility(id, visibility)])
     } else if (object_type === "model") {
@@ -33,18 +34,13 @@ export const useDataStyleStore = defineStore("dataStyle", () => {
     if (object_type === "mesh") {
       return meshStyleStore.applyMeshStyle(id)
     } else if (object_type === "model") {
-      return Promise.all([modelStyleStore.setModelVisibility(id, visible)])
+      return modelStyleStore.applyModelStyle(id)
     }
     return Promise.resolve([])
   }
 
   function setModelEdgesVisibility(id, visibility) {
-    modelStyleStore.setModelMeshComponentVisibility(
-      id,
-      "Edge",
-      null,
-      visibility,
-    )
+    modelStyleStore.setModelMeshComponentVisibility(id, "Edge", null, visibility)
   }
 
   function modelEdgesVisibility(id) {
@@ -57,52 +53,25 @@ export const useDataStyleStore = defineStore("dataStyle", () => {
 
   async function importStores(snapshot) {
     const stylesSnapshot = snapshot?.styles || {}
-    console.log(
-      "[DataStyle] importStores snapshot ids:",
-      Object.keys(stylesSnapshot),
-    )
-
-    // Conserver la référence réactive -> clear + merge
-    for (const id of Object.keys(dataStyleState.styles))
-      delete dataStyleState.styles[id]
+    for (const id of Object.keys(dataStyleState.styles)) delete dataStyleState.styles[id]
     for (const [id, style] of Object.entries(stylesSnapshot)) {
       dataStyleState.styles[id] = style
     }
-    console.log(
-      "[DataStyle] importStores merged ids:",
-      Object.keys(dataStyleState.styles),
-    )
   }
 
   async function applyAllStylesFromState() {
     const ids = Object.keys(dataStyleState.styles || {})
-    console.log("[DataStyle] applyAllStylesFromState start ids:", ids)
-
-    // Séquentiel par id pour mieux tracer et éviter les courses
     for (const id of ids) {
       const meta = dataBaseStore.itemMetaDatas(id)
       const objectType = meta?.object_type
       const style = dataStyleState.styles[id]
-      if (!style || !objectType) {
-        console.warn("[DataStyle] applyAllStylesFromState skip:", {
-          id,
-          hasStyle: !!style,
-          objectType,
-        })
-        continue
-      }
-      console.log("[DataStyle] applyAllStylesFromState applying:", {
-        id,
-        objectType,
-      })
+      if (!style || !objectType) continue
       if (objectType === "mesh") {
-        await meshStyleStore.applyMeshDefaultStyle(id)
+        await meshStyleStore.applyMeshStyle(id)
       } else if (objectType === "model") {
-        await modelStyleStore.applyModelDefaultStyle(id)
+        await modelStyleStore.applyModelStyle(id)
       }
-      console.log("[DataStyle] applyAllStylesFromState applied:", id)
     }
-    console.log("[DataStyle] applyAllStylesFromState finished")
   }
 
   return {
@@ -112,5 +81,10 @@ export const useDataStyleStore = defineStore("dataStyle", () => {
     addDataStyle,
     applyDefaultStyle,
     setVisibility,
+    setModelEdgesVisibility,
+    modelEdgesVisibility,
+    exportStores,
+    importStores,
+    applyAllStylesFromState,
   }
 })

stores/treeview.js

@@ -1,7 +1,4 @@
 export const useTreeviewStore = defineStore("treeview", () => {
-  const dataStyleStore = useDataStyleStore()
-  const dataBaseStore = useDataBaseStore()
-
   const items = ref([])
   const selection = ref([])
   const components_selection = ref([])
@@ -10,6 +7,9 @@ export const useTreeviewStore = defineStore("treeview", () => {
   const model_id = ref("")
   const isTreeCollection = ref(false)
   const selectedTree = ref(null)
+  const isImporting = ref(false)
+  // Buffer pour reconstruire la sélection après que les items soient recréés
+  const pendingSelectionIds = ref([])
 
   // /** Functions **/
   function addItem(geodeObject, displayed_name, id, object_type) {
@@ -24,12 +24,17 @@ export const useTreeviewStore = defineStore("treeview", () => {
             sensitivity: "base",
           }),
         )
-        selection.value.push(child)
+        // Ne pas polluer la sélection pendant import; on la reconstruit ensuite
+        if (!isImporting.value) {
+          selection.value.push(child)
+        }
         return
       }
     }
     items.value.push({ title: geodeObject, children: [child] })
-    selection.value.push(child)
+    if (!isImporting.value) {
+      selection.value.push(child)
+    }
   }
 
   function displayAdditionalTree(id) {
@@ -60,18 +65,38 @@ export const useTreeviewStore = defineStore("treeview", () => {
       model_id: model_id.value,
       isTreeCollection: isTreeCollection.value,
       selectedTree: selectedTree.value,
-      selection: selection.value,
+      // Exporter uniquement les IDs pour éviter les problèmes de référence
+      selectionIds: selection.value.map((c) => c.id),
     }
   }
 
   async function importStores(snapshot) {
-    selection.value = snapshot?.selection || []
+    // Charger l’état UI
     isAdditionnalTreeDisplayed.value =
       snapshot?.isAdditionnalTreeDisplayed || false
     panelWidth.value = snapshot?.panelWidth || 300
     model_id.value = snapshot?.model_id || ""
     isTreeCollection.value = snapshot?.isTreeCollection || false
     selectedTree.value = snapshot?.selectedTree || null
+
+    // Bufferiser les IDs de sélection (compat v1: snapshot.selection -> ids)
+    pendingSelectionIds.value =
+      snapshot?.selectionIds ||
+      (snapshot?.selection || []).map((c) => c.id) ||
+      []
+  }
+
+  // Appeler après import pour reconstruire la sélection à partir des items
+  function finalizeImportSelection() {
+    const ids = pendingSelectionIds.value || []
+    const rebuilt = []
+    for (const group of items.value) {
+      for (const child of group.children) {
+        if (ids.includes(child.id)) rebuilt.push(child)
+      }
+    }
+    selection.value = rebuilt
+    pendingSelectionIds.value = []
   }
 
   return {
@@ -90,5 +115,6 @@ export const useTreeviewStore = defineStore("treeview", () => {
     setPanelWidth,
     exportStores,
     importStores,
+    finalizeImportSelection,
   }
 })