@geode/opengeodeweb-front 9.12.2-rc.1 → 9.12.2-rc.2

package/internal_stores/model/corners.js

@@ -1,61 +1,98 @@
+// Third party imports
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
-const corners_schemas = viewer_schemas.opengeodeweb_viewer.model.corners
 
-export function useCornersStyle() {
-  /** State **/
+// Local constants
+const model_corners_schemas = viewer_schemas.opengeodeweb_viewer.model.corners
+
+export function useModelCornersStyle() {
   const dataStyleStore = useDataStyleStore()
   const dataBaseStore = useDataBaseStore()
 
-  /** Getters **/
-  function cornerVisibility(id, corner_id) {
-    return dataStyleStore.styles[id].corners[corner_id].visibility
+  function modelCornersStyle(id) {
+    return dataStyleStore.getStyle(id).corners
+  }
+  function modelCornerStyle(id, corner_id) {
+    if (!modelCornersStyle(id)[corner_id]) {
+      modelCornersStyle(id)[corner_id] = {}
+    }
+    return modelCornersStyle(id)[corner_id]
+  }
+
+  function modelCornerVisibility(id, corner_id) {
+    return modelCornerStyle(id, corner_id).visibility
   }
 
-  /** Actions **/
-  function setCornerVisibility(id, corner_ids, visibility) {
+  function saveModelCornerVisibility(id, corner_id, visibility) {
+    modelCornerStyle(id, corner_id).visibility = visibility
+  }
+  function setModelCornersVisibility(id, corner_ids, visibility) {
     const corner_flat_indexes = dataBaseStore.getFlatIndexes(id, corner_ids)
     return viewer_call(
       {
-        schema: corners_schemas.visibility,
+        schema: model_corners_schemas.visibility,
         params: { id, block_ids: corner_flat_indexes, visibility },
       },
       {
         response_function: () => {
           for (const corner_id of corner_ids) {
-            if (!dataStyleStore.styles[id].corners[corner_id])
-              dataStyleStore.styles[id].corners[corner_id] = {}
-            dataStyleStore.styles[id].corners[corner_id].visibility = visibility
+            saveModelCornerVisibility(id, corner_id, visibility)
           }
-          console.log("setCornerVisibility", corner_ids, visibility)
+          console.log(
+            setModelCornersVisibility.name,
+            { id },
+            { corner_ids },
+            modelCornerVisibility(id, corner_ids[0]),
+          )
         },
       },
     )
   }
 
-  function setCornersDefaultStyle(id) {
-    const corner_ids = dataBaseStore.getCornersUuids(id)
-    console.log(
-      "dataStyleStore.styles[id].corners.visibility",
-      dataStyleStore.styles[id].corners.visibility,
-    )
-    setCornerVisibility(
-      id,
-      corner_ids,
-      dataStyleStore.styles[id].corners.visibility,
+  function modelCornerColor(id, corner_id) {
+    return modelCornerStyle(id, corner_id).color
+  }
+
+  function saveModelCornerColor(id, corner_id, color) {
+    modelCornerStyle(id, corner_id).color = color
+  }
+
+  function setModelCornersColor(id, corner_ids, color) {
+    const corner_flat_indexes = dataBaseStore.getFlatIndexes(id, corner_ids)
+    return viewer_call(
+      {
+        schema: model_corners_schemas.color,
+        params: { id, block_ids: corner_flat_indexes, color },
+      },
+      {
+        response_function: () => {
+          for (const corner_id of corner_ids) {
+            saveModelCornerColor(id, corner_id, color)
+          }
+          console.log(
+            setModelCornersColor.name,
+            { id },
+            { corner_ids },
+            JSON.stringify(modelCornerColor(id, corner_ids[0])),
+          )
+        },
+      },
     )
   }
 
-  function applyCornersStyle(id) {
-    const corners = dataStyleStore.styles[id].corners
-    for (const [corner_id, style] of Object.entries(corners)) {
-      setCornerVisibility(id, [corner_id], style.visibility)
-    }
+  function applyModelCornersStyle(id) {
+    const style = modelCornersStyle(id)
+    const corner_ids = dataBaseStore.getCornersUuids(id)
+    return Promise.all([
+      setModelCornersVisibility(id, corner_ids, style.visibility),
+      setModelCornersColor(id, corner_ids, style.color),
+    ])
   }
 
   return {
-    cornerVisibility,
-    setCornersDefaultStyle,
-    setCornerVisibility,
-    applyCornersStyle,
+    modelCornerVisibility,
+    modelCornerColor,
+    setModelCornersVisibility,
+    setModelCornersColor,
+    applyModelCornersStyle,
   }
 }

package/internal_stores/model/edges.js

@@ -1,11 +1,17 @@
+// Third party imports
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+
+// Local constants
 const model_edges_schemas = viewer_schemas.opengeodeweb_viewer.model.edges
 
 export function useModelEdgesStyle() {
   const dataStyleStore = useDataStyleStore()
 
+  function modelEdgesStyle(id) {
+    return dataStyleStore.styles[id].edges
+  }
   function modelEdgesVisibility(id) {
-    return dataStyleStore.styles[id].edges.visibility
+    return modelEdgesStyle(id).visibility
   }
 
   function setModelEdgesVisibility(id, visibility) {
@@ -16,25 +22,25 @@ export function useModelEdgesStyle() {
       },
       {
         response_function: () => {
-          dataStyleStore.styles[id].edges.visibility = visibility
-          console.log("setModelEdgesVisibility", visibility)
+          modelEdgesStyle(id).visibility = visibility
+          console.log(
+            setModelEdgesVisibility.name,
+            { id },
+            modelEdgesVisibility(id),
+          )
         },
       },
     )
   }
 
-  function applyModelEdgesStyle(id, style) {
-    setModelEdgesVisibility(id, style.visibility)
-  }
-
-  function setModelEdgesDefaultStyle(id) {
-    setModelEdgesVisibility(id, false)
+  function applyModelEdgesStyle(id) {
+    const style = modelEdgesStyle(id)
+    return Promise.all([setModelEdgesVisibility(id, style.visibility)])
   }
 
   return {
     modelEdgesVisibility,
     setModelEdgesVisibility,
     applyModelEdgesStyle,
-    setModelEdgesDefaultStyle,
   }
 }

package/internal_stores/model/index.js

@@ -1,26 +1,45 @@
+// Third party imports
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
-import { useSurfacesStyle } from "./surfaces.js"
-import { useCornersStyle } from "./corners.js"
-import { useBlocksStyle } from "./blocks.js"
-import { useLinesStyle } from "./lines.js"
+
+// Local imports
+import { useModelSurfacesStyle } from "./surfaces.js"
+import { useModelCornersStyle } from "./corners.js"
+import { useModelBlocksStyle } from "./blocks.js"
+import { useModelLinesStyle } from "./lines.js"
 import { useModelEdgesStyle } from "./edges.js"
 import { useModelPointsStyle } from "./points.js"
 
+// Local constants
+const model_schemas = viewer_schemas.opengeodeweb_viewer.model
+
 export default function useModelStyle() {
-  /** States **/
   const dataBaseStore = useDataBaseStore()
   const dataStyleStore = useDataStyleStore()
-  const cornersStyleStore = useCornersStyle()
-  const linesStyleStore = useLinesStyle()
-  const surfacesStyleStore = useSurfacesStyle()
-  const blocksStyleStore = useBlocksStyle()
-  const modelEdgesStore = useModelEdgesStyle()
-  const modelPointsStore = useModelPointsStyle()
+  const modelCornersStyleStore = useModelCornersStyle()
+  const modelBlocksStyleStore = useModelBlocksStyle()
+  const modelEdgesStyleStore = useModelEdgesStyle()
+  const modelLinesStyleStore = useModelLinesStyle()
+  const modelPointsStyleStore = useModelPointsStyle()
+  const modelSurfacesStyleStore = useModelSurfacesStyle()
   const hybridViewerStore = useHybridViewerStore()
 
-  /** Getters **/
   function modelVisibility(id) {
-    return dataStyleStore.styles[id]?.visibility
+    return dataStyleStore.getStyle(id).visibility
+  }
+  function setModelVisibility(id, visibility) {
+    return viewer_call(
+      {
+        schema: model_schemas.visibility,
+        params: { id, visibility },
+      },
+      {
+        response_function: () => {
+          dataStyleStore.getStyle(id).visibility = visibility
+          hybridViewerStore.setVisibility(id, visibility)
+          console.log(setModelVisibility.name, { id }, modelVisibility(id))
+        },
+      },
+    )
   }
 
   function visibleMeshComponents(id) {
@@ -48,46 +67,31 @@ export default function useModelStyle() {
   }
 
   function modelMeshComponentVisibility(id, component_type, component_id) {
-    switch (component_type) {
-      case "Corner":
-        return cornersStyleStore.cornerVisibility(id, component_id)
-      case "Line":
-        return linesStyleStore.lineVisibility(id, component_id)
-      case "Surface":
-        return surfacesStyleStore.surfaceVisibility(id, component_id)
-      case "Block":
-        return blocksStyleStore.blockVisibility(id, component_id)
-      default:
-        return false
+    if (component_type === "Corner") {
+      return modelCornersStyleStore.modelCornerVisibility(id, component_id)
+    } else if (component_type === "Line") {
+      return modelLinesStyleStore.modelLineVisibility(id, component_id)
+    } else if (component_type === "Surface") {
+      return modelSurfacesStyleStore.modelSurfaceVisibility(id, component_id)
+    } else if (component_type === "Block") {
+      return modelBlocksStyleStore.modelBlockVisibility(id, component_id)
     }
+    throw new Error("Unknown model component_type: " + component_type)
   }
 
-  function setModelVisibility(id, visibility) {
-    return viewer_call(
-      {
-        schema: viewer_schemas.opengeodeweb_viewer.model.visibility,
-        params: { id, visibility },
-      },
-      {
-        response_function: () => {
-          dataStyleStore.styles[id].visibility = visibility
-          hybridViewerStore.setVisibility(id, visibility)
-          console.log("setModelVisibility", visibility)
-        },
-      },
-    )
+  function modelColor(id) {
+    return dataStyleStore.getStyle(id).color
   }
-
   function setModelColor(id, color) {
-    viewer_call(
+    return viewer_call(
       {
-        schema: viewer_schemas.opengeodeweb_viewer.model.color,
+        schema: model_schemas.color,
         params: { id, color },
       },
       {
         response_function: () => {
           dataStyleStore.styles[id].color = color
-          console.log("setModelColor", color)
+          console.log(setModelColor.name, { id }, modelColor(id))
         },
       },
     )
@@ -99,42 +103,78 @@ export default function useModelStyle() {
     component_id,
     visibility,
   ) {
-    switch (component_type) {
-      case "Corner":
-        cornersStyleStore.setCornerVisibility(id, [component_id], visibility)
-        break
-      case "Line":
-        linesStyleStore.setLineVisibility(id, [component_id], visibility)
-        break
-      case "Surface":
-        surfacesStyleStore.setSurfaceVisibility(id, [component_id], visibility)
-        break
-      case "Block":
-        blocksStyleStore.setBlockVisibility(id, [component_id], visibility)
-        break
+    if (component_type === "Corner") {
+      return modelCornersStyleStore.setModelCornersVisibility(
+        id,
+        [component_id],
+        visibility,
+      )
+    } else if (component_type === "Line") {
+      return modelLinesStyleStore.setModelLinesVisibility(
+        id,
+        [component_id],
+        visibility,
+      )
+    } else if (component_type === "Surface") {
+      return modelSurfacesStyleStore.setModelSurfacesVisibility(
+        id,
+        [component_id],
+        visibility,
+      )
+    } else if (component_type === "Block") {
+      return modelBlocksStyleStore.setModelBlocksVisibility(
+        id,
+        [component_id],
+        visibility,
+      )
+    } else {
+      throw new Error("Unknown model component_type: " + component_type)
     }
   }
 
-  function applyModelDefaultStyle(id) {
-    const id_style = dataStyleStore.styles[id]
-    for (const [key, value] of Object.entries(id_style)) {
-      if (key === "visibility") setModelVisibility(id, value)
-      else if (key === "edges") modelEdgesStore.applyModelEdgesStyle(id, value)
-      else if (key === "points")
-        modelPointsStore.applyModelPointsStyle(id, value)
+  function applyModelStyle(id) {
+    const style = dataStyleStore.getStyle(id)
+    const promise_array = []
+    for (const [key, value] of Object.entries(style)) {
+      if (key === "visibility") {
+        promise_array.push(setModelVisibility(id, value))
+      } else if (key === "corners") {
+        promise_array.push(modelCornersStyleStore.applyModelCornersStyle(id))
+      } else if (key === "lines") {
+        promise_array.push(modelLinesStyleStore.applyModelLinesStyle(id))
+      } else if (key === "surfaces") {
+        promise_array.push(modelSurfacesStyleStore.applyModelSurfacesStyle(id))
+      } else if (key === "blocks") {
+        promise_array.push(modelBlocksStyleStore.applyModelBlocksStyle(id))
+      } else if (key === "points") {
+        promise_array.push(modelPointsStyleStore.applyModelPointsStyle(id))
+      } else if (key === "edges") {
+        promise_array.push(modelEdgesStyleStore.applyModelEdgesStyle(id))
+      } else {
+        throw new Error("Unknown model key: " + key)
+      }
     }
+    return Promise.all(promise_array)
   }
 
-  function setMeshComponentsDefaultStyle(id) {
+  function setModelMeshComponentsDefaultStyle(id) {
     const { mesh_components } = dataBaseStore.itemMetaDatas(id)
-    if ("Corner" in mesh_components)
-      cornersStyleStore.setCornersDefaultStyle(id)
-    if ("Line" in mesh_components) linesStyleStore.setLinesDefaultStyle(id)
-    if ("Surface" in mesh_components)
-      surfacesStyleStore.setSurfacesDefaultStyle(id)
-    if ("Block" in mesh_components) blocksStyleStore.setBlocksDefaultStyle(id)
-    modelEdgesStore.setModelEdgesDefaultStyle(id)
-    modelPointsStore.setModelPointsDefaultStyle(id)
+    const promise_array = []
+    if ("Corner" in mesh_components) {
+      promise_array.push(modelCornersStyleStore.setModelCornersDefaultStyle(id))
+    }
+    if ("Line" in mesh_components) {
+      promise_array.push(modelLinesStyleStore.setModelLinesDefaultStyle(id))
+    }
+    if ("Surface" in mesh_components) {
+      promise_array.push(
+        modelSurfacesStyleStore.setModelSurfacesDefaultStyle(id),
+      )
+    }
+    if ("Block" in mesh_components) {
+      promise_array.push(modelBlocksStyleStore.setModelBlocksDefaultStyle(id))
+    }
+    return promise_array
   }
 
   return {
@@ -144,13 +184,13 @@ export default function useModelStyle() {
     setModelVisibility,
     setModelColor,
     setModelMeshComponentVisibility,
-    applyModelDefaultStyle,
-    setMeshComponentsDefaultStyle,
-    ...useSurfacesStyle(),
-    ...useCornersStyle(),
-    ...useBlocksStyle(),
-    ...useLinesStyle(),
+    applyModelStyle,
+    setModelMeshComponentsDefaultStyle,
+    ...useModelBlocksStyle(),
+    ...useModelCornersStyle(),
     ...useModelEdgesStyle(),
+    ...useModelLinesStyle(),
     ...useModelPointsStyle(),
+    ...useModelSurfacesStyle(),
   }
 }

package/internal_stores/model/lines.js

@@ -1,79 +1,96 @@
+// Third party imports
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
-const lines_schemas = viewer_schemas.opengeodeweb_viewer.model.lines
 
-export function useLinesStyle() {
-  /** State **/
+// Local constants
+const model_lines_schemas = viewer_schemas.opengeodeweb_viewer.model.lines
+
+export function useModelLinesStyle() {
   const dataStyleStore = useDataStyleStore()
   const dataBaseStore = useDataBaseStore()
 
-  /** Getters **/
-  function lineVisibility(id, line_id) {
-    return dataStyleStore.styles[id].lines[line_id].visibility
+  function modelLinesStyle(id) {
+    return dataStyleStore.getStyle(id).lines
+  }
+  function modelLineStyle(id, line_id) {
+    if (!modelLinesStyle(id)[line_id]) {
+      modelLinesStyle(id)[line_id] = {}
+    }
+    return modelLinesStyle(id)[line_id]
   }
 
-  function linesColor(id) {
-    return dataStyleStore.styles[id].lines.color
+  function modelLineVisibility(id, line_id) {
+    return modelLineStyle(id, line_id).visibility
   }
 
-  /** Actions **/
-  function setLineVisibility(id, line_ids, visibility) {
+  function saveModelLineVisibility(id, line_id, visibility) {
+    modelLineStyle(id, line_id).visibility = visibility
+  }
+  function setModelLinesVisibility(id, line_ids, visibility) {
     const line_flat_indexes = dataBaseStore.getFlatIndexes(id, line_ids)
     return viewer_call(
       {
-        schema: lines_schemas.visibility,
+        schema: model_lines_schemas.visibility,
         params: { id, block_ids: line_flat_indexes, visibility },
       },
       {
         response_function: () => {
           for (const line_id of line_ids) {
-            if (!dataStyleStore.styles[id].lines[line_id])
-              dataStyleStore.styles[id].lines[line_id] = {}
-            dataStyleStore.styles[id].lines[line_id].visibility = visibility
+            saveModelLineVisibility(id, line_id, visibility)
           }
-          console.log("setLineVisibility", line_ids, visibility)
+          console.log(
+            setModelLinesVisibility.name,
+            { id },
+            { line_ids },
+            modelLineVisibility(id, line_ids[0]),
+          )
         },
       },
     )
   }
 
-  function setLineColor(id, line_ids, color) {
+  function modelLineColor(id, line_id) {
+    return modelLineStyle(id, line_id).color
+  }
+  function saveModelLineColor(id, line_id, color) {
+    modelLineStyle(id, line_id).color = color
+  }
+  function setModelLinesColor(id, line_ids, color) {
     const line_flat_indexes = dataBaseStore.getFlatIndexes(id, line_ids)
     return viewer_call(
       {
-        schema: lines_schemas.color,
+        schema: model_lines_schemas.color,
         params: { id, block_ids: line_flat_indexes, color },
       },
       {
         response_function: () => {
           for (const line_id of line_ids) {
-            if (!dataStyleStore.styles[id].lines[line_id])
-              dataStyleStore.styles[id].lines[line_id] = {}
-            dataStyleStore.styles[id].lines[line_id].color = color
+            saveModelLineColor(id, line_id, color)
           }
-          console.log("setLineColor", line_ids, color)
+          console.log(
+            setModelLinesColor.name,
+            { id },
+            { line_ids },
+            JSON.stringify(modelLineColor(id, line_ids[0])),
+          )
         },
       },
     )
   }
 
-  function setLinesDefaultStyle(id) {
+  function applyModelLinesStyle(id) {
+    const style = modelLinesStyle(id)
     const line_ids = dataBaseStore.getLinesUuids(id)
-    setLineVisibility(id, line_ids, dataStyleStore.styles[id].lines.visibility)
-    setLineColor(id, line_ids, dataStyleStore.styles[id].lines.color)
-  }
-
-  function applyLinesStyle(id) {
-    const lines = dataStyleStore.styles[id].lines
-    for (const [line_id, style] of Object.entries(lines)) {
-      setLineVisibility(id, [line_id], style.visibility)
-    }
+    return Promise.all([
+      setModelLinesVisibility(id, line_ids, style.visibility),
+      setModelLinesColor(id, line_ids, style.color),
+    ])
   }
 
   return {
-    lineVisibility,
-    linesColor,
-    setLinesDefaultStyle,
-    setLineVisibility,
-    applyLinesStyle,
+    modelLineVisibility,
+    modelLineColor,
+    setModelLinesVisibility,
+    setModelLinesColor,
+    applyModelLinesStyle,
   }
 }

package/internal_stores/model/points.js

@@ -1,16 +1,18 @@
+// Third party imports
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+
+// Local constants
 const model_points_schemas = viewer_schemas.opengeodeweb_viewer.model.points
 
 export function useModelPointsStyle() {
   const dataStyleStore = useDataStyleStore()
 
-  function modelPointsVisibility(id) {
-    return dataStyleStore.styles[id].points.visibility
+  function modelPointsStyle(id) {
+    return dataStyleStore.getStyle(id).points
   }
-  function modelPointsSize(id) {
-    return dataStyleStore.styles[id].points.size
+  function modelPointsVisibility(id) {
+    return modelPointsStyle(id).visibility
   }
-
   function setModelPointsVisibility(id, visibility) {
     return viewer_call(
       {
@@ -19,13 +21,20 @@ export function useModelPointsStyle() {
       },
       {
         response_function: () => {
-          dataStyleStore.styles[id].points.visibility = visibility
-          console.log("setModelPointsVisibility", visibility)
+          modelPointsStyle(id).visibility = visibility
+          console.log(
+            setModelPointsVisibility.name,
+            { id },
+            modelPointsVisibility(id),
+          )
         },
       },
     )
   }
 
+  function modelPointsSize(id) {
+    return modelPointsStyle(id).size
+  }
   function setModelPointsSize(id, size) {
     return viewer_call(
       {
@@ -35,19 +44,18 @@ export function useModelPointsStyle() {
       {
         response_function: () => {
           dataStyleStore.styles[id].points.size = size
-          console.log("setModelPointsSize", size)
+          console.log(setModelPointsSize.name, { id }, modelPointsSize(id))
         },
       },
     )
   }
 
-  function applyModelPointsStyle(id, style) {
-    setModelPointsVisibility(id, style.visibility)
-    setModelPointsSize(id, style.size)
-  }
-
-  function setModelPointsDefaultStyle(id) {
-    setModelPointsVisibility(id, false)
+  function applyModelPointsStyle(id) {
+    const style = modelPointsStyle(id)
+    return Promise.all([
+      setModelPointsVisibility(id, style.visibility),
+      setModelPointsSize(id, style.size),
+    ])
   }
 
   return {
@@ -56,6 +64,5 @@ export function useModelPointsStyle() {
     setModelPointsVisibility,
     setModelPointsSize,
     applyModelPointsStyle,
-    setModelPointsDefaultStyle,
   }
 }