@geode/opengeodeweb-front 10.6.2 → 10.7.0-rc.1

package/app/stores/data.js

@@ -1,53 +1,51 @@
 // Third party imports
-import { liveQuery } from "dexie"
-import { useObservable } from "@vueuse/rxjs"
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+import { liveQuery } from "dexie";
+import { useObservable } from "@vueuse/rxjs";
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
 // Local imports
-import { database } from "@ogw_internal/database/database.js"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { database } from "@ogw_internal/database/database.js";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
-const viewer_generic_schemas = viewer_schemas.opengeodeweb_viewer.generic
+const viewer_generic_schemas = viewer_schemas.opengeodeweb_viewer.generic;
 
 export const useDataStore = defineStore("data", () => {
-  const viewerStore = useViewerStore()
+  const viewerStore = useViewerStore();
 
   function item(id) {
-    return database.data.get(id)
+    return database.data.get(id);
   }
 
   function refItem(id) {
     return useObservable(
       liveQuery(() => database.data.get(id)),
       { initialValue: {} },
-    )
+    );
   }
 
   function refAllItems() {
     return useObservable(
       liveQuery(() => database.data.toArray()),
       { initialValue: [] },
-    )
+    );
   }
 
   async function formatedMeshComponents(modelId) {
-    const items = await database.model_components
-      .where({ id: modelId })
-      .toArray()
+    const items = await database.model_components.where({ id: modelId }).toArray();
     const componentTitles = {
       Corner: "Corners",
       Line: "Lines",
       Surface: "Surfaces",
       Block: "Blocks",
-    }
+    };
 
-    const componentsByType = {}
+    const componentsByType = {};
     for (const component_item of items) {
       if (componentTitles[component_item.type]) {
         if (!componentsByType[component_item.type]) {
-          componentsByType[component_item.type] = []
+          componentsByType[component_item.type] = [];
         }
-        componentsByType[component_item.type].push(component_item)
+        componentsByType[component_item.type].push(component_item);
       }
     }
 
@@ -61,22 +59,20 @@ export const useDataStore = defineStore("data", () => {
           title: meshComponent.name,
           category: meshComponent.type,
         })),
-      }))
+      }));
   }
 
   async function meshComponentType(modelId, geode_id) {
-    const component = await database.model_components
-      .where({ id: modelId, geode_id })
-      .first()
-    return component?.type
+    const component = await database.model_components.where({ id: modelId, geode_id }).first();
+    return component?.type;
   }
 
   async function registerObject(id) {
-    return await viewerStore.request(viewer_generic_schemas.register, { id })
+    return await viewerStore.request(viewer_generic_schemas.register, { id });
   }
 
   async function deregisterObject(id) {
-    return await viewerStore.request(viewer_generic_schemas.deregister, { id })
+    return await viewerStore.request(viewer_generic_schemas.deregister, { id });
   }
 
   function addItem(new_item) {
@@ -88,12 +84,12 @@ export const useDataStore = defineStore("data", () => {
       visible: true,
       created_at: new Date().toISOString(),
       binary_light_viewable: new_item.binary_light_viewable,
-    }
-    return database.data.put(itemData)
+    };
+    return database.data.put(itemData);
   }
 
   function addComponents(new_item) {
-    const allComponents = []
+    const allComponents = [];
     function addModelComponents(components) {
       for (const component of components) {
         allComponents.push({
@@ -102,16 +98,16 @@ export const useDataStore = defineStore("data", () => {
           type: component.type,
           viewer_id: component.viewer_id,
           name: component.name,
-        })
+        });
       }
     }
-    addModelComponents(new_item.mesh_components)
-    addModelComponents(new_item.collection_components)
-    return database.model_components.bulkPut(allComponents)
+    addModelComponents(new_item.mesh_components);
+    addModelComponents(new_item.collection_components);
+    return database.model_components.bulkPut(allComponents);
   }
 
   function addComponentRelations(new_item) {
-    const relations = []
+    const relations = [];
     function addModelComponentRelations(components, parent, type) {
       for (const child of components) {
         relations.push({
@@ -119,93 +115,81 @@ export const useDataStore = defineStore("data", () => {
           parent,
           child,
           type,
-        })
+        });
       }
     }
     for (const component of new_item.mesh_components) {
       if (component.boundaries) {
-        addModelComponentRelations(
-          component.boundaries,
-          component.geode_id,
-          "boundary",
-        )
+        addModelComponentRelations(component.boundaries, component.geode_id, "boundary");
       }
       if (component.internals) {
-        addModelComponentRelations(
-          component.internals,
-          component.geode_id,
-          "internal",
-        )
+        addModelComponentRelations(component.internals, component.geode_id, "internal");
       }
     }
     for (const component of new_item.collection_components) {
       if (component.items) {
-        addModelComponentRelations(
-          component.items,
-          component.geode_id,
-          "collection",
-        )
+        addModelComponentRelations(component.items, component.geode_id, "collection");
       }
     }
-    return database.model_components_relation.bulkPut(relations)
+    return database.model_components_relation.bulkPut(relations);
   }
 
   async function deleteItem(id) {
-    await database.data.delete(id)
-    await deleteModelComponents(id)
+    await database.data.delete(id);
+    await deleteModelComponents(id);
   }
 
   async function updateItem(id, changes) {
-    await database.data.update(id, changes)
+    await database.data.update(id, changes);
   }
 
   async function deleteModelComponents(modelId) {
-    await database.model_components.where({ id: modelId }).delete()
-    await database.model_components_relation.where({ id: modelId }).delete()
+    await database.model_components.where({ id: modelId }).delete();
+    await database.model_components_relation.where({ id: modelId }).delete();
   }
 
   async function getMeshComponentGeodeIds(modelId, component_type) {
     const components = await database.model_components
       .where({ id: modelId, type: component_type })
-      .toArray()
-    return components.map((component) => component.geode_id)
+      .toArray();
+    return components.map((component) => component.geode_id);
   }
 
   async function getCornersGeodeIds(modelId) {
-    return await getMeshComponentGeodeIds(modelId, "Corner")
+    return await getMeshComponentGeodeIds(modelId, "Corner");
   }
 
   async function getLinesGeodeIds(modelId) {
-    return await getMeshComponentGeodeIds(modelId, "Line")
+    return await getMeshComponentGeodeIds(modelId, "Line");
   }
 
   async function getSurfacesGeodeIds(modelId) {
-    return await getMeshComponentGeodeIds(modelId, "Surface")
+    return await getMeshComponentGeodeIds(modelId, "Surface");
   }
 
   async function getBlocksGeodeIds(modelId) {
-    return await getMeshComponentGeodeIds(modelId, "Block")
+    return await getMeshComponentGeodeIds(modelId, "Block");
   }
 
   async function getMeshComponentsViewerIds(modelId, meshComponentGeodeIds) {
     const components = await database.model_components
       .where("[id+geode_id]")
       .anyOf(meshComponentGeodeIds.map((geode_id) => [modelId, geode_id]))
-      .toArray()
-    return components.map((component) => component.viewer_id)
+      .toArray();
+    return components.map((component) => component.viewer_id);
   }
 
   async function exportStores() {
-    const items = await database.data.toArray()
-    return { items }
+    const items = await database.data.toArray();
+    return { items };
   }
 
   async function importStores(_snapshot) {
-    await clear()
+    await clear();
   }
 
   async function clear() {
-    await database.data.clear()
+    await database.data.clear();
   }
 
   return {
@@ -229,5 +213,5 @@ export const useDataStore = defineStore("data", () => {
     exportStores,
     importStores,
     clear,
-  }
-})
+  };
+});

package/app/stores/data_style.js

@@ -1,78 +1,78 @@
-import { getDefaultStyle } from "@ogw_front/utils/default_styles"
-import { useDataStore } from "@ogw_front/stores/data"
-import { useDataStyleStateStore } from "@ogw_internal/stores/data_style/state"
-import { useMeshStyle } from "@ogw_internal/stores/data_style/mesh/index"
-import { useModelStyle } from "@ogw_internal/stores/data_style/model/index"
+import { getDefaultStyle } from "@ogw_front/utils/default_styles";
+import { useDataStore } from "@ogw_front/stores/data";
+import { useDataStyleStateStore } from "@ogw_internal/stores/data_style/state";
+import { useMeshStyle } from "@ogw_internal/stores/data_style/mesh/index";
+import { useModelStyle } from "@ogw_internal/stores/data_style/model/index";
 
 export const useDataStyleStore = defineStore("dataStyle", () => {
-  const dataStyleState = useDataStyleStateStore()
-  const meshStyleStore = useMeshStyle()
-  const modelStyleStore = useModelStyle()
-  const dataStore = useDataStore()
+  const dataStyleState = useDataStyleStateStore();
+  const meshStyleStore = useMeshStyle();
+  const modelStyleStore = useModelStyle();
+  const dataStore = useDataStore();
 
   function addDataStyle(id, geode_object) {
-    dataStyleState.styles[id] = getDefaultStyle(geode_object)
+    dataStyleState.styles[id] = getDefaultStyle(geode_object);
   }
 
   async function setVisibility(id, visibility) {
-    const item = await dataStore.item(id)
-    const viewer_type = item?.viewer_type
+    const item = await dataStore.item(id);
+    const viewer_type = item?.viewer_type;
     if (!viewer_type) {
-      throw new Error(`Item not found or not loaded: ${id}`)
+      throw new Error(`Item not found or not loaded: ${id}`);
     }
 
     if (viewer_type === "mesh") {
-      return meshStyleStore.setMeshVisibility(id, visibility)
+      return meshStyleStore.setMeshVisibility(id, visibility);
     }
     if (viewer_type === "model") {
-      return modelStyleStore.setModelVisibility(id, visibility)
+      return modelStyleStore.setModelVisibility(id, visibility);
     }
-    throw new Error("Unknown viewer_type")
+    throw new Error("Unknown viewer_type");
   }
 
   async function applyDefaultStyle(id) {
-    const item = await dataStore.item(id)
-    const viewer_type = item?.viewer_type
+    const item = await dataStore.item(id);
+    const viewer_type = item?.viewer_type;
     if (!viewer_type) {
-      throw new Error(`Item not found or not loaded: ${id}`)
+      throw new Error(`Item not found or not loaded: ${id}`);
     }
     if (viewer_type === "mesh") {
-      return meshStyleStore.applyMeshStyle(id)
+      return meshStyleStore.applyMeshStyle(id);
     }
     if (viewer_type === "model") {
-      return modelStyleStore.applyModelStyle(id)
+      return modelStyleStore.applyModelStyle(id);
     }
-    throw new Error(`Unknown viewer_type: ${viewer_type}`)
+    throw new Error(`Unknown viewer_type: ${viewer_type}`);
   }
 
   function exportStores() {
-    return { styles: dataStyleState.styles }
+    return { styles: dataStyleState.styles };
   }
 
   function importStores(snapshot) {
-    const stylesSnapshot = snapshot.styles || {}
+    const stylesSnapshot = snapshot.styles || {};
     for (const id of Object.keys(dataStyleState.styles)) {
-      delete dataStyleState.styles[id]
+      delete dataStyleState.styles[id];
     }
     for (const [id, style] of Object.entries(stylesSnapshot)) {
-      dataStyleState.styles[id] = style
+      dataStyleState.styles[id] = style;
     }
   }
 
   function applyAllStylesFromState() {
-    const ids = Object.keys(dataStyleState.styles || {})
+    const ids = Object.keys(dataStyleState.styles || {});
     const promises = ids.map(async (id) => {
-      const meta = await dataStore.item(id)
-      const viewerType = meta?.viewer_type
-      const style = dataStyleState.styles[id]
+      const meta = await dataStore.item(id);
+      const viewerType = meta?.viewer_type;
+      const style = dataStyleState.styles[id];
       if (style && viewerType === "mesh") {
-        return meshStyleStore.applyMeshStyle(id)
+        return meshStyleStore.applyMeshStyle(id);
       }
       if (style && viewerType === "model") {
-        return modelStyleStore.applyModelStyle(id)
+        return modelStyleStore.applyModelStyle(id);
       }
-    })
-    return Promise.all(promises)
+    });
+    return Promise.all(promises);
   }
 
   return {
@@ -88,5 +88,5 @@ export const useDataStyleStore = defineStore("dataStyle", () => {
     exportStores,
     importStores,
     applyAllStylesFromState,
-  }
-})
+  };
+});

package/app/stores/feedback.js

@@ -1,18 +1,17 @@
-import { v4 as uuidv4 } from "uuid"
+import { v4 as uuidv4 } from "uuid";
 
-const MILLISECONDS_IN_SECOND = 1000
-const DEFAULT_FEEDBACKS_TIMEOUT_SECONDS = 10
+const MILLISECONDS_IN_SECOND = 1000;
+const DEFAULT_FEEDBACKS_TIMEOUT_SECONDS = 10;
 
 export const useFeedbackStore = defineStore("feedback", {
   state: () => ({
     feedbacks: [],
     server_error: false,
-    feedbacks_timeout_miliseconds:
-      DEFAULT_FEEDBACKS_TIMEOUT_SECONDS * MILLISECONDS_IN_SECOND,
+    feedbacks_timeout_miliseconds: DEFAULT_FEEDBACKS_TIMEOUT_SECONDS * MILLISECONDS_IN_SECOND,
   }),
   actions: {
     async add_error(code, route, name, description) {
-      const feedbackId = uuidv4()
+      const feedbackId = uuidv4();
       await this.feedbacks.push({
         id: feedbackId,
         type: "error",
@@ -20,29 +19,27 @@ export const useFeedbackStore = defineStore("feedback", {
         route,
         name,
         description,
-      })
+      });
       setTimeout(() => {
-        this.delete_feedback(feedbackId)
-      }, this.feedbacks_timeout_miliseconds)
+        this.delete_feedback(feedbackId);
+      }, this.feedbacks_timeout_miliseconds);
     },
     async add_success(description) {
-      const feedbackId = uuidv4()
+      const feedbackId = uuidv4();
       await this.feedbacks.push({
         id: feedbackId,
         type: "success",
         description,
-      })
+      });
       setTimeout(() => {
-        this.delete_feedback(feedbackId)
-      }, this.feedbacks_timeout_miliseconds)
+        this.delete_feedback(feedbackId);
+      }, this.feedbacks_timeout_miliseconds);
     },
-    async delete_feedback(feedbackId) {
-      this.feedbacks = this.feedbacks.filter(
-        (feedback) => feedback.id !== feedbackId,
-      )
+    delete_feedback(feedbackId) {
+      this.feedbacks = this.feedbacks.filter((feedback) => feedback.id !== feedbackId);
     },
-    async delete_server_error() {
-      this.server_error = false
+    delete_server_error() {
+      this.server_error = false;
     },
   },
-})
+});

package/app/stores/geode.js

@@ -1,14 +1,14 @@
-import { Status } from "@ogw_front/utils/status"
-import { api_fetch } from "@ogw_internal/utils/api_fetch"
-import { appMode } from "@ogw_front/utils/local/app_mode"
-import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json"
-import { upload_file } from "@ogw_internal/utils/upload_file.js"
-import { useAppStore } from "@ogw_front/stores/app"
-import { useFeedbackStore } from "@ogw_front/stores/feedback"
-import { useInfraStore } from "@ogw_front/stores/infra"
+import { Status } from "@ogw_front/utils/status";
+import { api_fetch } from "@ogw_internal/utils/api_fetch";
+import { appMode } from "@ogw_front/utils/local/app_mode";
+import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json";
+import { upload_file } from "@ogw_internal/utils/upload_file.js";
+import { useAppStore } from "@ogw_front/stores/app";
+import { useFeedbackStore } from "@ogw_front/stores/feedback";
+import { useInfraStore } from "@ogw_front/stores/infra";
 
-const MILLISECONDS_IN_SECOND = 1000
-const DEFAULT_PING_INTERVAL_SECONDS = 10
+const MILLISECONDS_IN_SECOND = 1000;
+const DEFAULT_PING_INTERVAL_SECONDS = 10;
 
 export const useGeodeStore = defineStore("geode", {
   state: () => ({
@@ -19,69 +19,68 @@ export const useGeodeStore = defineStore("geode", {
   getters: {
     protocol() {
       if (useInfraStore().app_mode === appMode.CLOUD) {
-        return "https"
+        return "https";
       }
-      return "http"
+      return "http";
     },
     port() {
       if (useInfraStore().app_mode === appMode.CLOUD) {
-        return "443"
+        return "443";
       }
-      return this.default_local_port
+      return this.default_local_port;
     },
     base_url() {
-      const infraStore = useInfraStore()
-      let geode_url = `${this.protocol}://${infraStore.domain_name}:${this.port}`
+      const infraStore = useInfraStore();
+      let geode_url = `${this.protocol}://${infraStore.domain_name}:${this.port}`;
       if (infraStore.app_mode === appMode.CLOUD) {
         if (infraStore.ID === "") {
-          throw new Error("ID must not be empty in cloud mode")
+          throw new Error("ID must not be empty in cloud mode");
         }
-        geode_url += `/${infraStore.ID}/geode`
+        geode_url += `/${infraStore.ID}/geode`;
       }
-      return geode_url
+      return geode_url;
     },
     is_busy() {
-      return this.request_counter > 0
+      return this.request_counter > 0;
     },
   },
   actions: {
     set_ping() {
-      this.ping()
+      this.ping();
       setInterval(() => {
-        this.ping()
-      }, DEFAULT_PING_INTERVAL_SECONDS * MILLISECONDS_IN_SECOND)
+        this.ping();
+      }, DEFAULT_PING_INTERVAL_SECONDS * MILLISECONDS_IN_SECOND);
     },
     ping() {
-      const geodeStore = this
-      const feedbackStore = useFeedbackStore()
+      const feedbackStore = useFeedbackStore();
       return this.request(
         back_schemas.opengeodeweb_back.ping,
         {},
         {
           request_error_function: () => {
-            feedbackStore.$patch({ server_error: true })
-            geodeStore.status = Status.NOT_CONNECTED
+            feedbackStore.$patch({ server_error: true });
+            this.status = Status.NOT_CONNECTED;
           },
           response_function: () => {
-            feedbackStore.$patch({ server_error: false })
-            geodeStore.status = Status.CONNECTED
+            feedbackStore.$patch({ server_error: false });
+            this.status = Status.CONNECTED;
           },
           response_error_function: () => {
-            feedbackStore.$patch({ server_error: true })
-            geodeStore.status = Status.NOT_CONNECTED
+            feedbackStore.$patch({ server_error: true });
+            this.status = Status.NOT_CONNECTED;
           },
         },
-      )
+      );
     },
     start_request() {
-      this.request_counter += 1
+      this.request_counter += 1;
     },
     stop_request() {
-      this.request_counter -= 1
+      this.request_counter -= 1;
     },
     launch(args) {
-      console.log("[GEODE] Launching back microservice...", { args })
-      const appStore = useAppStore()
+      console.log("[GEODE] Launching back microservice...", { args });
+      const appStore = useAppStore();
       const schema = {
         $id: "/api/app/run_back",
         methods: ["POST"],
@@ -89,26 +88,26 @@ export const useGeodeStore = defineStore("geode", {
         properties: {},
         required: [],
         additionalProperties: true,
-      }
+      };
 
-      const params = { args }
+      const params = { args };
 
-      console.log("[GEODE] params", params)
+      console.log("[GEODE] params", params);
       return appStore.request(schema, params, {
         response_function: (response) => {
-          console.log(`[GEODE] Back launched on port ${response.port}`)
-          this.default_local_port = response.port
+          console.log(`[GEODE] Back launched on port ${response.port}`);
+          this.default_local_port = response.port;
         },
-      })
+      });
     },
     connect() {
-      console.log("[GEODE] Connecting to geode microservice...")
-      this.set_ping()
-      return Promise.resolve()
+      console.log("[GEODE] Connecting to geode microservice...");
+      this.set_ping();
+      return Promise.resolve();
     },
     request(schema, params, callbacks = {}) {
-      console.log("[GEODE] Request:", schema.$id)
-      const start = Date.now()
+      console.log("[GEODE] Request:", schema.$id);
+      const start = Date.now();
 
       return api_fetch(
         this,
@@ -122,16 +121,16 @@ export const useGeodeStore = defineStore("geode", {
               "in",
               (Date.now() - start) / MILLISECONDS_IN_SECOND,
               "s",
-            )
+            );
             if (callbacks.response_function) {
-              await callbacks.response_function(response)
+              await callbacks.response_function(response);
             }
           },
         },
-      )
+      );
     },
     upload(file, callbacks = {}) {
-      const route = back_schemas.opengeodeweb_back.upload_file.$id
+      const route = back_schemas.opengeodeweb_back.upload_file.$id;
       return upload_file(
         this,
         {
@@ -141,16 +140,16 @@ export const useGeodeStore = defineStore("geode", {
         {
           ...callbacks,
           response_function: async (response) => {
-            console.log("[GEODE] Request completed:", route)
+            console.log("[GEODE] Request completed:", route);
             if (callbacks.response_function) {
-              await callbacks.response_function(response)
+              await callbacks.response_function(response);
             }
           },
         },
-      )
+      );
     },
   },
   share: {
     omit: ["status"],
   },
-})
+});