@geode/opengeodeweb-front 10.4.1-rc.1 → 10.4.1

package/.oxlintrc.json

@@ -18,6 +18,7 @@
     "eslint/func-style": ["error", "declaration"],
     "eslint/sort-keys": "off",
     "eslint/no-ternary": "off", // A utiliser pour des opérations simples
+    "unicorn/prefer-ternary": "off",
     "oxc/no-async-await": "off",
     "oxc/no-rest-spread-properties": "off", // Enable if older browser support is needed
     "eslint/max-statements": ["warn", 20],
@@ -91,8 +92,7 @@
       "rules": {
         "vitest/require-hook": "off",
         "vitest/no-hooks": "off",
-        "vitest/no-importing-vitest-globals": "off",
-        "import/no-relative-parent-imports": "warn"
+        "vitest/no-importing-vitest-globals": "off"
       }
     },
     {

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

@@ -0,0 +1,64 @@
+// Third party imports
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+
+// Local imports
+import { useModelBlocksCommonStyle } from "./common"
+import { useDataStore } from "@ogw_front/stores/data"
+import { useViewerStore } from "@ogw_front/stores/viewer"
+
+// Local constants
+const model_blocks_schemas = viewer_schemas.opengeodeweb_viewer.model.blocks
+
+export function useModelBlocksColorStyle() {
+  const dataStore = useDataStore()
+  const viewerStore = useViewerStore()
+  const modelBlocksCommonStyle = useModelBlocksCommonStyle()
+
+  function modelBlockColor(id, block_id) {
+    return modelBlocksCommonStyle.modelBlockStyle(id, block_id).color
+  }
+
+  function saveModelBlockColor(id, block_id, color) {
+    modelBlocksCommonStyle.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])),
+          )
+        },
+      },
+    )
+  }
+
+  return {
+    modelBlockColor,
+    setModelBlocksColor,
+  }
+}

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

@@ -0,0 +1,21 @@
+import { useDataStyleStateStore } from "../../state"
+
+export function useModelBlocksCommonStyle() {
+  const dataStyleStateStore = useDataStyleStateStore()
+
+  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]
+  }
+
+  return {
+    modelBlocksStyle,
+    modelBlockStyle,
+  }
+}

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

@@ -0,0 +1,35 @@
+// Local imports
+import { useModelBlocksColorStyle } from "./color"
+import { useModelBlocksCommonStyle } from "./common"
+import { useModelBlocksVisibilityStyle } from "./visibility"
+import { useDataStore } from "@ogw_front/stores/data"
+
+export function useModelBlocksStyle() {
+  const dataStore = useDataStore()
+  const modelBlocksCommonStyle = useModelBlocksCommonStyle()
+  const modelBlocksVisibilityStyle = useModelBlocksVisibilityStyle()
+  const modelBlocksColorStyle = useModelBlocksColorStyle()
+
+  async function applyModelBlocksStyle(id) {
+    const style = modelBlocksCommonStyle.modelBlocksStyle(id)
+    const blocks_ids = await dataStore.getBlocksGeodeIds(id)
+    return Promise.all([
+      modelBlocksVisibilityStyle.setModelBlocksVisibility(
+        id,
+        blocks_ids,
+        style.visibility,
+      ),
+      modelBlocksColorStyle.setModelBlocksColor(id, blocks_ids, style.color),
+    ])
+  }
+
+  async function setModelBlocksDefaultStyle(id) {}
+
+  return {
+    applyModelBlocksStyle,
+    setModelBlocksDefaultStyle,
+    ...modelBlocksCommonStyle,
+    ...modelBlocksVisibilityStyle,
+    ...modelBlocksColorStyle,
+  }
+}

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

@@ -0,0 +1,63 @@
+// Third party imports
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+
+// Local imports
+import { useModelBlocksCommonStyle } from "./common"
+import { useDataStore } from "@ogw_front/stores/data"
+import { useViewerStore } from "@ogw_front/stores/viewer"
+
+// Local constants
+const model_blocks_schemas = viewer_schemas.opengeodeweb_viewer.model.blocks
+
+export function useModelBlocksVisibilityStyle() {
+  const dataStore = useDataStore()
+  const viewerStore = useViewerStore()
+  const modelBlocksCommonStyle = useModelBlocksCommonStyle()
+
+  function modelBlockVisibility(id, block_id) {
+    return modelBlocksCommonStyle.modelBlockStyle(id, block_id).visibility
+  }
+
+  function saveModelBlockVisibility(id, block_id, visibility) {
+    modelBlocksCommonStyle.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]),
+          )
+        },
+      },
+    )
+  }
+
+  return {
+    modelBlockVisibility,
+    setModelBlocksVisibility,
+  }
+}

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

@@ -0,0 +1,63 @@
+// Third party imports
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+
+// Local imports
+import { useModelCornersCommonStyle } from "./common"
+import { useDataStore } from "@ogw_front/stores/data"
+import { useViewerStore } from "@ogw_front/stores/viewer"
+
+// Local constants
+const model_corners_schemas = viewer_schemas.opengeodeweb_viewer.model.corners
+
+export function useModelCornersColorStyle() {
+  const dataStore = useDataStore()
+  const viewerStore = useViewerStore()
+  const modelCornersCommonStyle = useModelCornersCommonStyle()
+
+  function modelCornerColor(id, corner_id) {
+    return modelCornersCommonStyle.modelCornerStyle(id, corner_id).color
+  }
+
+  function saveModelCornerColor(id, corner_id, color) {
+    modelCornersCommonStyle.modelCornerStyle(id, corner_id).color = color
+  }
+
+  async function setModelCornersColor(id, corner_ids, color) {
+    if (!corner_ids || corner_ids.length === 0) {
+      return
+    }
+    const corner_viewer_ids = await dataStore.getMeshComponentsViewerIds(
+      id,
+      corner_ids,
+    )
+    if (!corner_viewer_ids || corner_viewer_ids.length === 0) {
+      console.warn(
+        "[setModelCornersColor] No viewer IDs found, skipping color request",
+        { id, corner_ids },
+      )
+      return
+    }
+    return viewerStore.request(
+      model_corners_schemas.color,
+      { id, block_ids: corner_viewer_ids, 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])),
+          )
+        },
+      },
+    )
+  }
+
+  return {
+    modelCornerColor,
+    setModelCornersColor,
+  }
+}

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

@@ -0,0 +1,21 @@
+import { useDataStyleStateStore } from "../../state"
+
+export function useModelCornersCommonStyle() {
+  const dataStyleStateStore = useDataStyleStateStore()
+
+  function modelCornersStyle(id) {
+    return dataStyleStateStore.getStyle(id).corners
+  }
+
+  function modelCornerStyle(id, corner_id) {
+    if (!modelCornersStyle(id)[corner_id]) {
+      modelCornersStyle(id)[corner_id] = {}
+    }
+    return modelCornersStyle(id)[corner_id]
+  }
+
+  return {
+    modelCornersStyle,
+    modelCornerStyle,
+  }
+}

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

@@ -0,0 +1,36 @@
+// Local imports
+import { useModelCornersColorStyle } from "./color"
+import { useModelCornersCommonStyle } from "./common"
+import { useModelCornersVisibilityStyle } from "./visibility"
+import { useDataStore } from "@ogw_front/stores/data"
+
+export function useModelCornersStyle() {
+  const dataStore = useDataStore()
+  const modelCornersCommonStyle = useModelCornersCommonStyle()
+  const modelCornersVisibilityStyle = useModelCornersVisibilityStyle()
+  const modelCornersColorStyle = useModelCornersColorStyle()
+
+  async function applyModelCornersStyle(id) {
+    const style = modelCornersCommonStyle.modelCornersStyle(id)
+    const corner_ids = await dataStore.getCornersGeodeIds(id)
+    console.log(applyModelCornersStyle.name, { id }, { corner_ids })
+    return Promise.all([
+      modelCornersVisibilityStyle.setModelCornersVisibility(
+        id,
+        corner_ids,
+        style.visibility,
+      ),
+      modelCornersColorStyle.setModelCornersColor(id, corner_ids, style.color),
+    ])
+  }
+
+  async function setModelCornersDefaultStyle(id) {}
+
+  return {
+    applyModelCornersStyle,
+    setModelCornersDefaultStyle,
+    ...modelCornersCommonStyle,
+    ...modelCornersVisibilityStyle,
+    ...modelCornersColorStyle,
+  }
+}

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

@@ -0,0 +1,64 @@
+// Third party imports
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+
+// Local imports
+import { useModelCornersCommonStyle } from "./common"
+import { useDataStore } from "@ogw_front/stores/data"
+import { useViewerStore } from "@ogw_front/stores/viewer"
+
+// Local constants
+const model_corners_schemas = viewer_schemas.opengeodeweb_viewer.model.corners
+
+export function useModelCornersVisibilityStyle() {
+  const dataStore = useDataStore()
+  const viewerStore = useViewerStore()
+  const modelCornersCommonStyle = useModelCornersCommonStyle()
+
+  function modelCornerVisibility(id, corner_id) {
+    return modelCornersCommonStyle.modelCornerStyle(id, corner_id).visibility
+  }
+
+  function saveModelCornerVisibility(id, corner_id, visibility) {
+    modelCornersCommonStyle.modelCornerStyle(id, corner_id).visibility =
+      visibility
+  }
+
+  async function setModelCornersVisibility(id, corner_ids, visibility) {
+    if (!corner_ids || corner_ids.length === 0) {
+      return
+    }
+    const corner_viewer_ids = await dataStore.getMeshComponentsViewerIds(
+      id,
+      corner_ids,
+    )
+    if (!corner_viewer_ids || corner_viewer_ids.length === 0) {
+      console.warn(
+        "[setModelCornersVisibility] No viewer IDs found, skipping visibility request",
+        { id, corner_ids },
+      )
+      return
+    }
+    return viewerStore.request(
+      model_corners_schemas.visibility,
+      { id, block_ids: corner_viewer_ids, visibility },
+      {
+        response_function: () => {
+          for (const corner_id of corner_ids) {
+            saveModelCornerVisibility(id, corner_id, visibility)
+          }
+          console.log(
+            setModelCornersVisibility.name,
+            { id },
+            { corner_ids },
+            modelCornerVisibility(id, corner_ids[0]),
+          )
+        },
+      },
+    )
+  }
+
+  return {
+    modelCornerVisibility,
+    setModelCornersVisibility,
+  }
+}

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

@@ -0,0 +1,13 @@
+import { useDataStyleStateStore } from "../../state"
+
+export function useModelEdgesCommonStyle() {
+  const dataStyleStateStore = useDataStyleStateStore()
+
+  function modelEdgesStyle(id) {
+    return dataStyleStateStore.styles[id].edges
+  }
+
+  return {
+    modelEdgesStyle,
+  }
+}

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

@@ -0,0 +1,21 @@
+// Local imports
+import { useModelEdgesCommonStyle } from "./common"
+import { useModelEdgesVisibilityStyle } from "./visibility"
+
+export function useModelEdgesStyle() {
+  const modelEdgesCommonStyle = useModelEdgesCommonStyle()
+  const modelEdgesVisibilityStyle = useModelEdgesVisibilityStyle()
+
+  function applyModelEdgesStyle(id) {
+    const style = modelEdgesCommonStyle.modelEdgesStyle(id)
+    return Promise.resolve([
+      modelEdgesVisibilityStyle.setModelEdgesVisibility(id, style.visibility),
+    ])
+  }
+
+  return {
+    applyModelEdgesStyle,
+    ...modelEdgesCommonStyle,
+    ...modelEdgesVisibilityStyle,
+  }
+}

package/internal/stores/data_style/model/{edges.js → edges/visibility.js}

@@ -2,21 +2,18 @@
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
 
 // Local imports
-import { useDataStyleStateStore } from "../state"
+import { useModelEdgesCommonStyle } from "./common"
 import { useViewerStore } from "@ogw_front/stores/viewer"
 
 // Local constants
 const model_edges_schemas = viewer_schemas.opengeodeweb_viewer.model.edges
 
-export function useModelEdgesStyle() {
-  const dataStyleStateStore = useDataStyleStateStore()
+export function useModelEdgesVisibilityStyle() {
   const viewerStore = useViewerStore()
+  const modelEdgesCommonStyle = useModelEdgesCommonStyle()
 
-  function modelEdgesStyle(id) {
-    return dataStyleStateStore.styles[id].edges
-  }
   function modelEdgesVisibility(id) {
-    return modelEdgesStyle(id).visibility
+    return modelEdgesCommonStyle.modelEdgesStyle(id).visibility
   }
 
   function setModelEdgesVisibility(id, visibility) {
@@ -25,7 +22,7 @@ export function useModelEdgesStyle() {
       { id, visibility },
       {
         response_function: () => {
-          modelEdgesStyle(id).visibility = visibility
+          modelEdgesCommonStyle.modelEdgesStyle(id).visibility = visibility
           console.log(
             setModelEdgesVisibility.name,
             { id },
@@ -36,14 +33,8 @@ export function useModelEdgesStyle() {
     )
   }
 
-  function applyModelEdgesStyle(id) {
-    const style = modelEdgesStyle(id)
-    return Promise.resolve([setModelEdgesVisibility(id, style.visibility)])
-  }
-
   return {
     modelEdgesVisibility,
     setModelEdgesVisibility,
-    applyModelEdgesStyle,
   }
 }

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,
+  }
+}