@geode/opengeodeweb-front 10.4.0 → 10.4.1-rc.2

package/internal/stores/data_style/model/index.js

@@ -171,9 +171,9 @@ export default function useModelStyle() {
     return Promise.all(promise_array)
   }
 
-  function setModelMeshComponentsDefaultStyle(id) {
-    const item = dataStore.getItem(id)
-    const { mesh_components } = item.value
+  async function setModelMeshComponentsDefaultStyle(id) {
+    const item = await dataStore.item(id)
+    const { mesh_components } = item
     const promise_array = []
     if ("Corner" in mesh_components) {
       promise_array.push(modelCornersStyleStore.setModelCornersDefaultStyle(id))

package/internal/stores/data_style/model/lines/color.js

@@ -0,0 +1,63 @@
+// Third party imports
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+
+// Local imports
+import { useModelLinesCommonStyle } from "./common"
+import { useDataStore } from "@ogw_front/stores/data"
+import { useViewerStore } from "@ogw_front/stores/viewer"
+
+// Local constants
+const model_lines_schemas = viewer_schemas.opengeodeweb_viewer.model.lines
+
+export function useModelLinesColorStyle() {
+  const dataStore = useDataStore()
+  const viewerStore = useViewerStore()
+  const modelLinesCommonStyle = useModelLinesCommonStyle()
+
+  function modelLineColor(id, line_id) {
+    return modelLinesCommonStyle.modelLineStyle(id, line_id).color
+  }
+
+  function saveModelLineColor(id, line_id, color) {
+    modelLinesCommonStyle.modelLineStyle(id, line_id).color = color
+  }
+
+  async function setModelLinesColor(id, line_ids, color) {
+    if (!line_ids || line_ids.length === 0) {
+      return
+    }
+    const line_viewer_ids = await dataStore.getMeshComponentsViewerIds(
+      id,
+      line_ids,
+    )
+    if (!line_viewer_ids || line_viewer_ids.length === 0) {
+      console.warn(
+        "[setModelLinesColor] No viewer IDs found, skipping color request",
+        { id, line_ids },
+      )
+      return
+    }
+    return viewerStore.request(
+      model_lines_schemas.color,
+      { id, block_ids: line_viewer_ids, color },
+      {
+        response_function: () => {
+          for (const line_id of line_ids) {
+            saveModelLineColor(id, line_id, color)
+          }
+          console.log(
+            setModelLinesColor.name,
+            { id },
+            { line_ids },
+            JSON.stringify(modelLineColor(id, line_ids[0])),
+          )
+        },
+      },
+    )
+  }
+
+  return {
+    modelLineColor,
+    setModelLinesColor,
+  }
+}

package/internal/stores/data_style/model/lines/common.js

@@ -0,0 +1,21 @@
+import { useDataStyleStateStore } from "../../state"
+
+export function useModelLinesCommonStyle() {
+  const dataStyleStateStore = useDataStyleStateStore()
+
+  function modelLinesStyle(id) {
+    return dataStyleStateStore.getStyle(id).lines
+  }
+
+  function modelLineStyle(id, line_id) {
+    if (!modelLinesStyle(id)[line_id]) {
+      modelLinesStyle(id)[line_id] = {}
+    }
+    return modelLinesStyle(id)[line_id]
+  }
+
+  return {
+    modelLinesStyle,
+    modelLineStyle,
+  }
+}

package/internal/stores/data_style/model/lines/index.js

@@ -0,0 +1,35 @@
+// Local imports
+import { useModelLinesColorStyle } from "./color"
+import { useModelLinesCommonStyle } from "./common"
+import { useModelLinesVisibilityStyle } from "./visibility"
+import { useDataStore } from "@ogw_front/stores/data"
+
+export function useModelLinesStyle() {
+  const dataStore = useDataStore()
+  const modelLinesCommonStyle = useModelLinesCommonStyle()
+  const modelLinesVisibilityStyle = useModelLinesVisibilityStyle()
+  const modelLinesColorStyle = useModelLinesColorStyle()
+
+  async function applyModelLinesStyle(id) {
+    const style = modelLinesCommonStyle.modelLinesStyle(id)
+    const line_ids = await dataStore.getLinesGeodeIds(id)
+    return Promise.all([
+      modelLinesVisibilityStyle.setModelLinesVisibility(
+        id,
+        line_ids,
+        style.visibility,
+      ),
+      modelLinesColorStyle.setModelLinesColor(id, line_ids, style.color),
+    ])
+  }
+
+  async function setModelLinesDefaultStyle(id) {}
+
+  return {
+    applyModelLinesStyle,
+    setModelLinesDefaultStyle,
+    ...modelLinesCommonStyle,
+    ...modelLinesVisibilityStyle,
+    ...modelLinesColorStyle,
+  }
+}

package/internal/stores/data_style/model/lines/visibility.js

@@ -0,0 +1,63 @@
+// Third party imports
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+
+// Local imports
+import { useModelLinesCommonStyle } from "./common"
+import { useDataStore } from "@ogw_front/stores/data"
+import { useViewerStore } from "@ogw_front/stores/viewer"
+
+// Local constants
+const model_lines_schemas = viewer_schemas.opengeodeweb_viewer.model.lines
+
+export function useModelLinesVisibilityStyle() {
+  const dataStore = useDataStore()
+  const viewerStore = useViewerStore()
+  const modelLinesCommonStyle = useModelLinesCommonStyle()
+
+  function modelLineVisibility(id, line_id) {
+    return modelLinesCommonStyle.modelLineStyle(id, line_id).visibility
+  }
+
+  function saveModelLineVisibility(id, line_id, visibility) {
+    modelLinesCommonStyle.modelLineStyle(id, line_id).visibility = visibility
+  }
+
+  async function setModelLinesVisibility(id, line_ids, visibility) {
+    if (!line_ids || line_ids.length === 0) {
+      return
+    }
+    const line_viewer_ids = await dataStore.getMeshComponentsViewerIds(
+      id,
+      line_ids,
+    )
+    if (!line_viewer_ids || line_viewer_ids.length === 0) {
+      console.warn(
+        "[setModelLinesVisibility] No viewer IDs found, skipping visibility request",
+        { id, line_ids },
+      )
+      return
+    }
+    return viewerStore.request(
+      model_lines_schemas.visibility,
+      { id, block_ids: line_viewer_ids, visibility },
+      {
+        response_function: () => {
+          for (const line_id of line_ids) {
+            saveModelLineVisibility(id, line_id, visibility)
+          }
+          console.log(
+            setModelLinesVisibility.name,
+            { id },
+            { line_ids },
+            modelLineVisibility(id, line_ids[0]),
+          )
+        },
+      },
+    )
+  }
+
+  return {
+    modelLineVisibility,
+    setModelLinesVisibility,
+  }
+}

package/internal/stores/data_style/model/points/common.js

@@ -0,0 +1,13 @@
+import { useDataStyleStateStore } from "../../state"
+
+export function useModelPointsCommonStyle() {
+  const dataStyleStateStore = useDataStyleStateStore()
+
+  function modelPointsStyle(id) {
+    return dataStyleStateStore.getStyle(id).points
+  }
+
+  return {
+    modelPointsStyle,
+  }
+}

package/internal/stores/data_style/model/points/index.js

@@ -0,0 +1,25 @@
+// Local imports
+import { useModelPointsCommonStyle } from "./common"
+import { useModelPointsSizeStyle } from "./size"
+import { useModelPointsVisibilityStyle } from "./visibility"
+
+export function useModelPointsStyle() {
+  const modelPointsCommonStyle = useModelPointsCommonStyle()
+  const modelPointsVisibilityStyle = useModelPointsVisibilityStyle()
+  const modelPointsSizeStyle = useModelPointsSizeStyle()
+
+  function applyModelPointsStyle(id) {
+    const style = modelPointsCommonStyle.modelPointsStyle(id)
+    return Promise.all([
+      modelPointsVisibilityStyle.setModelPointsVisibility(id, style.visibility),
+      modelPointsSizeStyle.setModelPointsSize(id, style.size),
+    ])
+  }
+
+  return {
+    applyModelPointsStyle,
+    ...modelPointsCommonStyle,
+    ...modelPointsVisibilityStyle,
+    ...modelPointsSizeStyle,
+  }
+}

package/internal/stores/data_style/model/points/size.js

@@ -0,0 +1,36 @@
+// Third party imports
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+
+// Local imports
+import { useModelPointsCommonStyle } from "./common"
+import { useViewerStore } from "@ogw_front/stores/viewer"
+
+// Local constants
+const model_points_schemas = viewer_schemas.opengeodeweb_viewer.model.points
+
+export function useModelPointsSizeStyle() {
+  const viewerStore = useViewerStore()
+  const modelPointsCommonStyle = useModelPointsCommonStyle()
+
+  function modelPointsSize(id) {
+    return modelPointsCommonStyle.modelPointsStyle(id).size
+  }
+
+  function setModelPointsSize(id, size) {
+    return viewerStore.request(
+      model_points_schemas.size,
+      { id, size },
+      {
+        response_function: () => {
+          modelPointsCommonStyle.modelPointsStyle(id).size = size
+          console.log(setModelPointsSize.name, { id }, modelPointsSize(id))
+        },
+      },
+    )
+  }
+
+  return {
+    modelPointsSize,
+    setModelPointsSize,
+  }
+}

package/internal/stores/data_style/model/points/visibility.js

@@ -0,0 +1,40 @@
+// Third party imports
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+
+// Local imports
+import { useModelPointsCommonStyle } from "./common"
+import { useViewerStore } from "@ogw_front/stores/viewer"
+
+// Local constants
+const model_points_schemas = viewer_schemas.opengeodeweb_viewer.model.points
+
+export function useModelPointsVisibilityStyle() {
+  const viewerStore = useViewerStore()
+  const modelPointsCommonStyle = useModelPointsCommonStyle()
+
+  function modelPointsVisibility(id) {
+    return modelPointsCommonStyle.modelPointsStyle(id).visibility
+  }
+
+  function setModelPointsVisibility(id, visibility) {
+    return viewerStore.request(
+      model_points_schemas.visibility,
+      { id, visibility },
+      {
+        response_function: () => {
+          modelPointsCommonStyle.modelPointsStyle(id).visibility = visibility
+          console.log(
+            setModelPointsVisibility.name,
+            { id },
+            modelPointsVisibility(id),
+          )
+        },
+      },
+    )
+  }
+
+  return {
+    modelPointsVisibility,
+    setModelPointsVisibility,
+  }
+}

package/internal/stores/data_style/model/surfaces/color.js

@@ -0,0 +1,62 @@
+// Third party imports
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+
+// Local imports
+import { useModelSurfacesCommonStyle } from "./common"
+import { useDataStore } from "@ogw_front/stores/data"
+import { useViewerStore } from "@ogw_front/stores/viewer"
+
+// Local constants
+const model_surfaces_schemas = viewer_schemas.opengeodeweb_viewer.model.surfaces
+
+export function useModelSurfacesColorStyle() {
+  const dataStore = useDataStore()
+  const viewerStore = useViewerStore()
+  const modelSurfacesCommonStyle = useModelSurfacesCommonStyle()
+
+  function modelSurfaceColor(id, surface_id) {
+    return modelSurfacesCommonStyle.modelSurfaceStyle(id, surface_id).color
+  }
+  function saveModelSurfaceColor(id, surface_id, color) {
+    modelSurfacesCommonStyle.modelSurfaceStyle(id, surface_id).color = color
+  }
+
+  async function setModelSurfacesColor(id, surface_ids, color) {
+    if (!surface_ids || surface_ids.length === 0) {
+      return
+    }
+    const surface_viewer_ids = await dataStore.getMeshComponentsViewerIds(
+      id,
+      surface_ids,
+    )
+    if (!surface_viewer_ids || surface_viewer_ids.length === 0) {
+      console.warn(
+        "[setModelSurfacesColor] No viewer IDs found, skipping color request",
+        { id, surface_ids },
+      )
+      return
+    }
+    return viewerStore.request(
+      model_surfaces_schemas.color,
+      { id, block_ids: surface_viewer_ids, color },
+      {
+        response_function: () => {
+          for (const surface_id of surface_ids) {
+            saveModelSurfaceColor(id, surface_id, color)
+          }
+          console.log(
+            setModelSurfacesColor.name,
+            { id },
+            { surface_ids },
+            JSON.stringify(modelSurfaceColor(id, surface_ids[0])),
+          )
+        },
+      },
+    )
+  }
+
+  return {
+    modelSurfaceColor,
+    setModelSurfacesColor,
+  }
+}

package/internal/stores/data_style/model/surfaces/common.js

@@ -0,0 +1,21 @@
+import { useDataStyleStateStore } from "../../state"
+
+export function useModelSurfacesCommonStyle() {
+  const dataStyleStateStore = useDataStyleStateStore()
+
+  function modelSurfacesStyle(id) {
+    return dataStyleStateStore.getStyle(id).surfaces
+  }
+
+  function modelSurfaceStyle(id, surface_id) {
+    if (!modelSurfacesStyle(id)[surface_id]) {
+      modelSurfacesStyle(id)[surface_id] = {}
+    }
+    return modelSurfacesStyle(id)[surface_id]
+  }
+
+  return {
+    modelSurfacesStyle,
+    modelSurfaceStyle,
+  }
+}

package/internal/stores/data_style/model/surfaces/index.js

@@ -0,0 +1,39 @@
+// Local imports
+import { useModelSurfacesColorStyle } from "./color"
+import { useModelSurfacesCommonStyle } from "./common"
+import { useModelSurfacesVisibilityStyle } from "./visibility"
+import { useDataStore } from "@ogw_front/stores/data"
+
+export function useModelSurfacesStyle() {
+  const dataStore = useDataStore()
+  const modelSurfacesCommonStyle = useModelSurfacesCommonStyle()
+  const modelSurfacesVisibilityStyle = useModelSurfacesVisibilityStyle()
+  const modelSurfacesColorStyle = useModelSurfacesColorStyle()
+
+  async function applyModelSurfacesStyle(id) {
+    const style = modelSurfacesCommonStyle.modelSurfacesStyle(id)
+    const surface_ids = await dataStore.getSurfacesGeodeIds(id)
+    return Promise.all([
+      modelSurfacesVisibilityStyle.setModelSurfacesVisibility(
+        id,
+        surface_ids,
+        style.visibility,
+      ),
+      modelSurfacesColorStyle.setModelSurfacesColor(
+        id,
+        surface_ids,
+        style.color,
+      ),
+    ])
+  }
+
+  async function setModelSurfacesDefaultStyle(id) {}
+
+  return {
+    applyModelSurfacesStyle,
+    setModelSurfacesDefaultStyle,
+    ...modelSurfacesCommonStyle,
+    ...modelSurfacesVisibilityStyle,
+    ...modelSurfacesColorStyle,
+  }
+}

package/internal/stores/data_style/model/surfaces/visibility.js

@@ -0,0 +1,62 @@
+// Third party imports
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+
+// Local imports
+import { useModelSurfacesCommonStyle } from "./common"
+import { useDataStore } from "@ogw_front/stores/data"
+import { useViewerStore } from "@ogw_front/stores/viewer"
+
+// Local constants
+const model_surfaces_schemas = viewer_schemas.opengeodeweb_viewer.model.surfaces
+
+export function useModelSurfacesVisibilityStyle() {
+  const dataStore = useDataStore()
+  const viewerStore = useViewerStore()
+  const modelSurfacesCommonStyle = useModelSurfacesCommonStyle()
+
+  function modelSurfaceVisibility(id, surface_id) {
+    return modelSurfacesCommonStyle.modelSurfaceStyle(id, surface_id).visibility
+  }
+  function saveModelSurfaceVisibility(id, surface_id, visibility) {
+    modelSurfacesCommonStyle.modelSurfaceStyle(id, surface_id).visibility =
+      visibility
+  }
+  async function setModelSurfacesVisibility(id, surface_ids, visibility) {
+    if (!surface_ids || surface_ids.length === 0) {
+      return
+    }
+    const surface_viewer_ids = await dataStore.getMeshComponentsViewerIds(
+      id,
+      surface_ids,
+    )
+    if (!surface_viewer_ids || surface_viewer_ids.length === 0) {
+      console.warn(
+        "[setModelSurfacesVisibility] No viewer IDs found, skipping visibility request",
+        { id, surface_ids },
+      )
+      return
+    }
+    return viewerStore.request(
+      model_surfaces_schemas.visibility,
+      { id, block_ids: surface_viewer_ids, visibility },
+      {
+        response_function: () => {
+          for (const surface_id of surface_ids) {
+            saveModelSurfaceVisibility(id, surface_id, visibility)
+          }
+          console.log(
+            setModelSurfacesVisibility.name,
+            { id },
+            { surface_ids },
+            modelSurfaceVisibility(id, surface_ids[0]),
+          )
+        },
+      },
+    )
+  }
+
+  return {
+    modelSurfaceVisibility,
+    setModelSurfacesVisibility,
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geode/opengeodeweb-front",
-  "version": "10.4.0",
+  "version": "10.4.1-rc.2",
   "description": "OpenSource Vue/Nuxt/Pinia/Vuetify framework for web applications",
   "homepage": "https://github.com/Geode-solutions/OpenGeodeWeb-Front",
   "bugs": {
@@ -31,8 +31,8 @@
     "build": ""
   },
   "dependencies": {
-    "@geode/opengeodeweb-back": "latest",
-    "@geode/opengeodeweb-viewer": "latest",
+    "@geode/opengeodeweb-back": "next",
+    "@geode/opengeodeweb-viewer": "next",
     "@kitware/vtk.js": "33.3.0",
     "@mdi/font": "7.4.47",
     "@pinia/nuxt": "0.11.3",

package/tests/integration/microservices/back/requirements.txt

@@ -5,4 +5,4 @@
 #    pip-compile --output-file=tests/integration/microservices/back/requirements.txt tests/integration/microservices/back/requirements.in
 #
 
-opengeodeweb-back==6.*,>=6.2.0rc2
+opengeodeweb-back==6.*,>=6.3.1rc1

package/tests/integration/microservices/viewer/requirements.txt

@@ -5,4 +5,4 @@
 #    pip-compile --output-file=tests/integration/microservices/viewer/requirements.txt tests/integration/microservices/viewer/requirements.in
 #
 
-opengeodeweb-viewer==1.*,>=1.15.4rc1
+opengeodeweb-viewer==1.*,>=1.15.5rc1

package/internal/stores/data_style/model/blocks.js

@@ -1,126 +0,0 @@
-// Third party imports
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
-
-// Local imports
-import { useDataStore } from "@ogw_front/stores/data"
-import { useDataStyleStateStore } from "../state"
-import { useViewerStore } from "@ogw_front/stores/viewer"
-
-// Local constants
-const model_blocks_schemas = viewer_schemas.opengeodeweb_viewer.model.blocks
-
-export function useModelBlocksStyle() {
-  const dataStyleStateStore = useDataStyleStateStore()
-  const dataStore = useDataStore()
-  const viewerStore = useViewerStore()
-
-  function modelBlocksStyle(id) {
-    return dataStyleStateStore.getStyle(id).blocks
-  }
-  function modelBlockStyle(id, block_id) {
-    if (!modelBlocksStyle(id)[block_id]) {
-      modelBlocksStyle(id)[block_id] = {}
-    }
-    return modelBlocksStyle(id)[block_id]
-  }
-
-  function modelBlockVisibility(id, block_id) {
-    return modelBlockStyle(id, block_id).visibility
-  }
-
-  function saveModelBlockVisibility(id, block_id, visibility) {
-    modelBlockStyle(id, block_id).visibility = visibility
-  }
-  async function setModelBlocksVisibility(id, block_ids, visibility) {
-    if (!block_ids || block_ids.length === 0) {
-      return
-    }
-    const blocks_viewer_ids = await dataStore.getMeshComponentsViewerIds(
-      id,
-      block_ids,
-    )
-    if (!blocks_viewer_ids || blocks_viewer_ids.length === 0) {
-      console.warn(
-        "[setModelBlocksVisibility] No viewer IDs found, skipping visibility request",
-        { id, block_ids },
-      )
-      return
-    }
-    return viewerStore.request(
-      model_blocks_schemas.visibility,
-      { id, block_ids: blocks_viewer_ids, visibility },
-      {
-        response_function: () => {
-          for (const block_id of block_ids) {
-            saveModelBlockVisibility(id, block_id, visibility)
-          }
-          console.log(
-            setModelBlocksVisibility.name,
-            { id },
-            { block_ids },
-            modelBlockVisibility(id, block_ids[0]),
-          )
-        },
-      },
-    )
-  }
-  function modelBlockColor(id, block_id) {
-    return modelBlockStyle(id, block_id).color
-  }
-
-  function saveModelBlockColor(id, block_id, color) {
-    modelBlockStyle(id, block_id).color = color
-  }
-
-  async function setModelBlocksColor(id, block_ids, color) {
-    if (!block_ids || block_ids.length === 0) {
-      return
-    }
-    const blocks_viewer_ids = await dataStore.getMeshComponentsViewerIds(
-      id,
-      block_ids,
-    )
-    if (!blocks_viewer_ids || blocks_viewer_ids.length === 0) {
-      console.warn(
-        "[setModelBlocksColor] No viewer IDs found, skipping color request",
-        { id, block_ids },
-      )
-      return
-    }
-    return viewerStore.request(
-      model_blocks_schemas.color,
-      { id, block_ids: blocks_viewer_ids, color },
-      {
-        response_function: () => {
-          for (const block_id of block_ids) {
-            saveModelBlockColor(id, block_id, color)
-          }
-
-          console.log(
-            setModelBlocksColor.name,
-            { id },
-            { block_ids },
-            JSON.stringify(modelBlockColor(id, block_ids[0])),
-          )
-        },
-      },
-    )
-  }
-
-  async function applyModelBlocksStyle(id) {
-    const style = modelBlocksStyle(id)
-    const blocks_ids = await dataStore.getBlocksGeodeIds(id)
-    return Promise.all([
-      setModelBlocksVisibility(id, blocks_ids, style.visibility),
-      setModelBlocksColor(id, blocks_ids, style.color),
-    ])
-  }
-
-  return {
-    modelBlockVisibility,
-    modelBlockColor,
-    setModelBlocksVisibility,
-    setModelBlocksColor,
-    applyModelBlocksStyle,
-  }
-}